From 8ab17680a84e0582ba66cbe436551e3f123a62f6 Mon Sep 17 00:00:00 2001
From: Moritz <mosum@google.com>
Date: Thu, 22 Aug 2024 13:22:26 +0200
Subject: [PATCH 01/16] Squashed commits

---
 pkgs/intl4x/example_native/.gitignore         |   4 +
 pkgs/intl4x/example_native/README.md          |   2 +
 .../example_native/analysis_options.yaml      |  30 ++
 .../example_native/bin/example_native.dart    |   6 +
 pkgs/intl4x/example_native/pubspec.yaml       |  17 ++
 .../{example => example_web}/.gitignore       |   0
 .../intl4x/{example => example_web}/README.md |   0
 .../analysis_options.yaml                     |   0
 .../{example => example_web}/pubspec.yaml     |   0
 .../{example => example_web}/web/index.html   |   0
 .../{example => example_web}/web/main.dart    |   0
 .../{example => example_web}/web/styles.css   |   0
 pkgs/intl4x/hook/build.dart                   | 268 +++++++++++++-----
 pkgs/intl4x/hook/link.dart                    |  89 ++++++
 pkgs/intl4x/lib/src/hook_helpers/locales.dart |   5 +
 pkgs/intl4x/lib/src/hook_helpers/shared.dart  |   6 +
 pkgs/intl4x/lib/src/locale/locale_native.dart |   2 +-
 pkgs/intl4x/pubspec.yaml                      |  16 +-
 18 files changed, 377 insertions(+), 68 deletions(-)
 create mode 100644 pkgs/intl4x/example_native/.gitignore
 create mode 100644 pkgs/intl4x/example_native/README.md
 create mode 100644 pkgs/intl4x/example_native/analysis_options.yaml
 create mode 100644 pkgs/intl4x/example_native/bin/example_native.dart
 create mode 100644 pkgs/intl4x/example_native/pubspec.yaml
 rename pkgs/intl4x/{example => example_web}/.gitignore (100%)
 rename pkgs/intl4x/{example => example_web}/README.md (100%)
 rename pkgs/intl4x/{example => example_web}/analysis_options.yaml (100%)
 rename pkgs/intl4x/{example => example_web}/pubspec.yaml (100%)
 rename pkgs/intl4x/{example => example_web}/web/index.html (100%)
 rename pkgs/intl4x/{example => example_web}/web/main.dart (100%)
 rename pkgs/intl4x/{example => example_web}/web/styles.css (100%)
 create mode 100644 pkgs/intl4x/hook/link.dart
 create mode 100644 pkgs/intl4x/lib/src/hook_helpers/locales.dart
 create mode 100644 pkgs/intl4x/lib/src/hook_helpers/shared.dart

diff --git a/pkgs/intl4x/example_native/.gitignore b/pkgs/intl4x/example_native/.gitignore
new file mode 100644
index 00000000..3be127c5
--- /dev/null
+++ b/pkgs/intl4x/example_native/.gitignore
@@ -0,0 +1,4 @@
+# https://dart.dev/guides/libraries/private-files
+# Created by `dart pub`
+.dart_tool/
+/bin/example_native/
diff --git a/pkgs/intl4x/example_native/README.md b/pkgs/intl4x/example_native/README.md
new file mode 100644
index 00000000..3816eca3
--- /dev/null
+++ b/pkgs/intl4x/example_native/README.md
@@ -0,0 +1,2 @@
+A sample command-line application with an entrypoint in `bin/`, library code
+in `lib/`, and example unit test in `test/`.
diff --git a/pkgs/intl4x/example_native/analysis_options.yaml b/pkgs/intl4x/example_native/analysis_options.yaml
new file mode 100644
index 00000000..dee8927a
--- /dev/null
+++ b/pkgs/intl4x/example_native/analysis_options.yaml
@@ -0,0 +1,30 @@
+# This file configures the static analysis results for your project (errors,
+# warnings, and lints).
+#
+# This enables the 'recommended' set of lints from `package:lints`.
+# This set helps identify many issues that may lead to problems when running
+# or consuming Dart code, and enforces writing Dart using a single, idiomatic
+# style and format.
+#
+# If you want a smaller set of lints you can change this to specify
+# 'package:lints/core.yaml'. These are just the most critical lints
+# (the recommended set includes the core lints).
+# The core lints are also what is used by pub.dev for scoring packages.
+
+include: package:lints/recommended.yaml
+
+# Uncomment the following section to specify additional rules.
+
+# linter:
+#   rules:
+#     - camel_case_types
+
+# analyzer:
+#   exclude:
+#     - path/to/excluded/files/**
+
+# For more information about the core and recommended set of lints, see
+# https://dart.dev/go/core-lints
+
+# For additional information about configuring this file, see
+# https://dart.dev/guides/language/analysis-options
diff --git a/pkgs/intl4x/example_native/bin/example_native.dart b/pkgs/intl4x/example_native/bin/example_native.dart
new file mode 100644
index 00000000..72e1dd04
--- /dev/null
+++ b/pkgs/intl4x/example_native/bin/example_native.dart
@@ -0,0 +1,6 @@
+import 'package:intl4x/intl4x.dart';
+
+void main(List<String> arguments) {
+  final intl = Intl();
+  print('collation: ${intl.collation().compare('a', 'b')}!');
+}
diff --git a/pkgs/intl4x/example_native/pubspec.yaml b/pkgs/intl4x/example_native/pubspec.yaml
new file mode 100644
index 00000000..00fc43be
--- /dev/null
+++ b/pkgs/intl4x/example_native/pubspec.yaml
@@ -0,0 +1,17 @@
+name: example_native
+description: A sample command-line application.
+version: 1.0.0
+# repository: https://github.com/my_org/my_repo
+
+publish_to: none
+
+environment:
+  sdk: ^3.6.0-78.0.dev
+
+dependencies:
+  intl4x:
+    path: ../
+
+dev_dependencies:
+  lints: ^4.0.0
+  test: ^1.24.0
diff --git a/pkgs/intl4x/example/.gitignore b/pkgs/intl4x/example_web/.gitignore
similarity index 100%
rename from pkgs/intl4x/example/.gitignore
rename to pkgs/intl4x/example_web/.gitignore
diff --git a/pkgs/intl4x/example/README.md b/pkgs/intl4x/example_web/README.md
similarity index 100%
rename from pkgs/intl4x/example/README.md
rename to pkgs/intl4x/example_web/README.md
diff --git a/pkgs/intl4x/example/analysis_options.yaml b/pkgs/intl4x/example_web/analysis_options.yaml
similarity index 100%
rename from pkgs/intl4x/example/analysis_options.yaml
rename to pkgs/intl4x/example_web/analysis_options.yaml
diff --git a/pkgs/intl4x/example/pubspec.yaml b/pkgs/intl4x/example_web/pubspec.yaml
similarity index 100%
rename from pkgs/intl4x/example/pubspec.yaml
rename to pkgs/intl4x/example_web/pubspec.yaml
diff --git a/pkgs/intl4x/example/web/index.html b/pkgs/intl4x/example_web/web/index.html
similarity index 100%
rename from pkgs/intl4x/example/web/index.html
rename to pkgs/intl4x/example_web/web/index.html
diff --git a/pkgs/intl4x/example/web/main.dart b/pkgs/intl4x/example_web/web/main.dart
similarity index 100%
rename from pkgs/intl4x/example/web/main.dart
rename to pkgs/intl4x/example_web/web/main.dart
diff --git a/pkgs/intl4x/example/web/styles.css b/pkgs/intl4x/example_web/web/styles.css
similarity index 100%
rename from pkgs/intl4x/example/web/styles.css
rename to pkgs/intl4x/example_web/web/styles.css
diff --git a/pkgs/intl4x/hook/build.dart b/pkgs/intl4x/hook/build.dart
index 9c9832d4..e43d949b 100644
--- a/pkgs/intl4x/hook/build.dart
+++ b/pkgs/intl4x/hook/build.dart
@@ -6,13 +6,12 @@ import 'dart:io';
 
 import 'package:crypto/crypto.dart' show sha256;
 import 'package:intl4x/src/hook_helpers/hashes.dart';
+import 'package:intl4x/src/hook_helpers/shared.dart';
 import 'package:intl4x/src/hook_helpers/version.dart';
 import 'package:native_assets_cli/native_assets_cli.dart';
 import 'package:path/path.dart' as path;
 
 const crateName = 'icu_capi';
-const package = 'intl4x';
-const assetId = 'src/bindings/lib.g.dart';
 
 final env = 'ICU4X_BUILD_MODE';
 
@@ -34,26 +33,12 @@ Unknown build mode for icu4x. Set the `ICU4X_BUILD_MODE` environment variable wi
 '''),
     };
 
-    final builtLibrary = await buildMode.build();
+    final buildResult = await buildMode.build();
     // For debugging purposes
     // ignore: deprecated_member_use
     output.addMetadatum(env, environmentBuildMode ?? 'fetch');
-
-    output.addAsset(NativeCodeAsset(
-      package: package,
-      name: assetId,
-      linkMode: DynamicLoadingBundled(),
-      architecture: config.targetArchitecture,
-      os: config.targetOS,
-      file: builtLibrary,
-    ));
-
-    output.addDependencies(
-      [
-        ...buildMode.dependencies,
-        config.packageRoot.resolve('hook/build.dart'),
-      ],
-    );
+    buildResult.addAssets(config, output);
+    output.addDependencies(buildMode.dependencies);
   });
 }
 
@@ -64,26 +49,74 @@ sealed class BuildMode {
 
   List<Uri> get dependencies;
 
-  Future<Uri> build();
+  Future<BuildResult> build();
+}
+
+final class BuildResult {
+  final Uri library;
+  final Uri? datagen;
+  final Uri? postcard;
+
+  BuildResult({
+    required this.library,
+    required this.datagen,
+    required this.postcard,
+  });
+
+  void addAssets(BuildConfig config, BuildOutput output) {
+    output.addAssets(
+      [
+        NativeCodeAsset(
+          package: package,
+          name: assetId,
+          linkMode: DynamicLoadingBundled(),
+          architecture: config.targetArchitecture,
+          os: config.targetOS,
+          file: library,
+        ),
+        if (datagen != null)
+          DataAsset(
+            package: package,
+            name: 'datagen',
+            file: datagen!,
+          ),
+        if (postcard != null)
+          DataAsset(
+            package: package,
+            name: 'postcard',
+            file: postcard!,
+          ),
+      ],
+      linkInPackage: config.linkingEnabled ? config.packageName : null,
+    );
+  }
 }
 
 final class FetchMode extends BuildMode {
   FetchMode(super.config);
+  final httpClient = HttpClient();
 
   @override
-  Future<Uri> build() async {
+  Future<BuildResult> build() async {
     final target = '${config.targetOS}_${config.targetArchitecture}';
-    final uri = Uri.parse(
+    final dylibRemoteUri = Uri.parse(
         'https://github.com/dart-lang/i18n/releases/download/$version/$target');
-    final request = await HttpClient().getUrl(uri);
-    final response = await request.close();
-    if (response.statusCode != 200) {
-      throw ArgumentError('The request to $uri failed');
-    }
-    final dynamicLibrary = File.fromUri(
-        config.outputDirectory.resolve(config.targetOS.dylibFileName('icu4x')));
-    await dynamicLibrary.create();
-    await response.pipe(dynamicLibrary.openWrite());
+    final dynamicLibrary = await fetchToFile(
+      dylibRemoteUri,
+      config.outputDirectory.resolve(config.filename('icu4x')),
+    );
+
+    final datagen = await fetchToFile(
+      Uri.parse(
+          'https://github.com/dart-lang/i18n/releases/download/$version/$target-datagen'),
+      config.outputDirectory.resolve('datagen'),
+    );
+
+    final postcard = await fetchToFile(
+      Uri.parse(
+          'https://github.com/dart-lang/i18n/releases/download/$version/full.postcard'),
+      config.outputDirectory.resolve('full.postcard'),
+    );
 
     final bytes = await dynamicLibrary.readAsBytes();
     final fileHash = sha256.convert(bytes).toString();
@@ -92,13 +125,29 @@ final class FetchMode extends BuildMode {
       config.targetArchitecture,
     )];
     if (fileHash == expectedFileHash) {
-      return dynamicLibrary.uri;
+      return BuildResult(
+        library: dynamicLibrary.uri,
+        datagen: datagen.uri,
+        postcard: postcard.uri,
+      );
     } else {
       throw Exception(
-          'The pre-built binary for the target $target at $uri has a hash of '
-          '$fileHash, which does not match $expectedFileHash fixed in the '
-          'build hook of package:intl4x.');
+          'The pre-built binary for the target $target at $dylibRemoteUri has a'
+          ' hash of $fileHash, which does not match $expectedFileHash fixed in'
+          ' the build hook of package:intl4x.');
+    }
+  }
+
+  Future<File> fetchToFile(Uri uri, Uri fileUri) async {
+    final request = await httpClient.getUrl(uri);
+    final response = await request.close();
+    if (response.statusCode != 200) {
+      throw ArgumentError('The request to $uri failed');
     }
+    final file = File.fromUri(fileUri);
+    await file.create();
+    await response.pipe(file.openWrite());
+    return file;
   }
 
   @override
@@ -106,33 +155,60 @@ final class FetchMode extends BuildMode {
 }
 
 final class LocalMode extends BuildMode {
-  LocalMode(super.config);
-
-  String get _localBinaryPath {
-    final localPath = Platform.environment['LOCAL_ICU4X_BINARY'];
-    if (localPath != null) {
+  final String localLibraryPath;
+  final String? localDatagenPath;
+  final String? localPostcardPath;
+
+  LocalMode(super.config)
+      : localLibraryPath = _getFromEnvironment(
+          'LOCAL_ICU4X_BINARY_${config.linkingEnabled ? 'STATIC' : 'DYNAMIC'}',
+          true,
+        )!,
+        localDatagenPath = _getFromEnvironment('LOCAL_ICU4X_DATAGEN', false),
+        localPostcardPath = _getFromEnvironment('LOCAL_ICU4X_POSTCARD', false);
+
+  static String? _getFromEnvironment(String key, bool mustExist) {
+    final localPath = Platform.environment[key];
+    if (localPath != null || !mustExist) {
       return localPath;
     }
-    throw ArgumentError('`LOCAL_ICU4X_BINARY` is empty. '
+    throw ArgumentError('`$key` is empty. '
         'If the `ICU4X_BUILD_MODE` is set to `local`, the '
-        '`LOCAL_ICU4X_BINARY` environment variable must contain the path to '
-        'the binary.');
+        '`$key` environment variable must be set.');
   }
 
   @override
-  Future<Uri> build() async {
-    final dylibFileName = config.targetOS.dylibFileName('icu4x');
-    final dylibFileUri = config.outputDirectory.resolve(dylibFileName);
-    final file = File(_localBinaryPath);
-    if (!(await file.exists())) {
-      throw FileSystemException('Could not find binary.', _localBinaryPath);
+  Future<BuildResult> build() async {
+    final libFileUri = config.outputDirectory.resolve(config.filename('icu4x'));
+    await copyFile(localLibraryPath, libFileUri);
+
+    final Uri? datagenFileUri;
+    if (localDatagenPath != null) {
+      datagenFileUri = config.outputDirectory.resolve('datagen');
+      await copyFile(localDatagenPath!, datagenFileUri);
+    } else {
+      datagenFileUri = null;
+    }
+
+    final Uri? postcardFileUri;
+    if (localPostcardPath != null) {
+      postcardFileUri = config.outputDirectory.resolve('postcard');
+      await copyFile(localPostcardPath!, postcardFileUri);
+    } else {
+      postcardFileUri = null;
     }
-    await file.copy(dylibFileUri.toFilePath(windows: Platform.isWindows));
-    return dylibFileUri;
+
+    return BuildResult(
+      library: libFileUri,
+      datagen: datagenFileUri,
+      postcard: postcardFileUri,
+    );
   }
 
   @override
-  List<Uri> get dependencies => [Uri.file(_localBinaryPath)];
+  List<Uri> get dependencies => [
+        Uri.file(localLibraryPath),
+      ];
 }
 
 final class CheckoutMode extends BuildMode {
@@ -141,7 +217,7 @@ final class CheckoutMode extends BuildMode {
   String? get workingDirectory => Platform.environment['LOCAL_ICU4X_CHECKOUT'];
 
   @override
-  Future<Uri> build() async {
+  Future<BuildResult> build() async {
     if (workingDirectory == null) {
       throw ArgumentError('Specify the ICU4X checkout folder'
           'with the LOCAL_ICU4X_CHECKOUT variable');
@@ -155,10 +231,14 @@ final class CheckoutMode extends BuildMode {
       ];
 }
 
-Future<Uri> buildLib(BuildConfig config, String workingDirectory) async {
-  final dylibFileName =
-      config.targetOS.dylibFileName(crateName.replaceAll('-', '_'));
-  final dylibFileUri = config.outputDirectory.resolve(dylibFileName);
+Future<BuildResult> buildLib(
+    BuildConfig config, String workingDirectory) async {
+  final crateNameFixed = crateName.replaceAll('-', '_');
+  final libFileName = config.filename(crateNameFixed);
+
+  final libFileUri = config.outputDirectory.resolve(libFileName);
+  final datagenFileUri = config.outputDirectory.resolve('datagen');
+  final postcardFileUri = config.outputDirectory.resolve('postcard');
   if (!config.dryRun) {
     final rustTarget = _asRustTarget(
       config.targetOS,
@@ -204,9 +284,7 @@ Future<Uri> buildLib(BuildConfig config, String workingDirectory) async {
       'panic-handler',
       'experimental_components',
     ];
-    final linkModeType = config.linkModePreference == LinkModePreference.static
-        ? 'staticlib'
-        : 'cdylib';
+    final linkModeType = config.buildStatic ? 'staticlib' : 'cdylib';
     final arguments = [
       if (isNoStd) '+nightly',
       'rustc',
@@ -242,15 +320,58 @@ Future<Uri> buildLib(BuildConfig config, String workingDirectory) async {
       tempDir.path,
       rustTarget,
       'release',
-      dylibFileName,
+      libFileName,
     );
-    final file = File(builtPath);
-    if (!(await file.exists())) {
-      throw FileSystemException('Building the dylib failed', builtPath);
+    await copyFile(builtPath, libFileUri);
+
+    if (config.linkingEnabled) {
+      final postcardPath = path.join(tempDir.path, 'full.postcard');
+      await Process.run(
+        'cargo',
+        [
+          'run',
+          ...['-p', 'icu_datagen'],
+          '--',
+          ...['--locales', 'full'],
+          ...['--keys', 'all'],
+          ...['--format', 'blob'],
+          ...['--out', postcardPath],
+        ],
+        workingDirectory: workingDirectory,
+      );
+      await copyFile(postcardPath, postcardFileUri);
+
+      final datagenPath = path.join(tempDir.path, 'datagen');
+      final datagenDirectory = path.join(workingDirectory, 'provider/datagen');
+      await Process.run(
+        'rustup',
+        ['target', 'add', 'aarch64-unknown-linux-gnu'],
+        workingDirectory: datagenDirectory,
+      );
+      await Process.run(
+        'cargo',
+        [
+          'build',
+          '--release',
+          '--bin',
+          'icu4x-datagen',
+          '--no-default-features',
+          ...[
+            '--features',
+            'bin,blob_exporter,blob_input,rayon,experimental_components'
+          ],
+          ...['--target', 'aarch64-unknown-linux-gnu']
+        ],
+        workingDirectory: datagenDirectory,
+      );
+      await copyFile(datagenPath, datagenFileUri);
     }
-    await file.copy(dylibFileUri.toFilePath(windows: Platform.isWindows));
   }
-  return dylibFileUri;
+  return BuildResult(
+    library: libFileUri,
+    datagen: config.linkingEnabled ? datagenFileUri : null,
+    postcard: config.linkingEnabled ? postcardFileUri : null,
+  );
 }
 
 String _asRustTarget(OS os, Architecture? architecture, bool isSimulator) {
@@ -287,3 +408,18 @@ bool _isNoStdTarget((OS os, Architecture? architecture) arg) => [
       (OS.android, Architecture.riscv64),
       (OS.linux, Architecture.riscv64)
     ].contains(arg);
+
+extension on BuildConfig {
+  bool get buildStatic =>
+      linkModePreference == LinkModePreference.static || linkingEnabled;
+  String Function(String) get filename =>
+      buildStatic ? targetOS.staticlibFileName : targetOS.dylibFileName;
+}
+
+Future<void> copyFile(String path, Uri libFileUri) async {
+  final file = File(path);
+  if (!(await file.exists())) {
+    throw FileSystemException('File does not exist.', path);
+  }
+  await file.copy(libFileUri.toFilePath(windows: Platform.isWindows));
+}
diff --git a/pkgs/intl4x/hook/link.dart b/pkgs/intl4x/hook/link.dart
new file mode 100644
index 00000000..60c65858
--- /dev/null
+++ b/pkgs/intl4x/hook/link.dart
@@ -0,0 +1,89 @@
+// Copyright (c) 2024, 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 'dart:io';
+
+import 'package:collection/collection.dart';
+import 'package:intl4x/src/hook_helpers/locales.dart';
+import 'package:intl4x/src/hook_helpers/shared.dart';
+import 'package:logging/logging.dart';
+import 'package:native_assets_cli/native_assets_cli.dart';
+import 'package:native_toolchain_c/native_toolchain_c.dart';
+
+// TODO(mosuem): Use `record_use` to automagically get the used symbols.
+const usedSymbols = <String>[
+  'diplomat_buffer_writeable_create',
+  'diplomat_buffer_writeable_get_bytes',
+  'diplomat_buffer_writeable_len',
+  'diplomat_buffer_writeable_destroy',
+  'ICU4XCollator_create_v1',
+  'ICU4XCollator_compare_utf16_',
+  'ICU4XDataProvider_create_compiled',
+  'ICU4XDataProvider_create_empty',
+  'ICU4XLocale_create_und',
+  'ICU4XLocale_set_language',
+  'ICU4XLocale_set_region',
+  'ICU4XLocale_set_script',
+  'ICU4XLocale_to_string',
+  'ICU4XLocale_total_cmp_',
+  //additional
+  'ICU4XDataProvider_create_compiled',
+  'ICU4XDataProvider_destroy',
+  'ICU4XLocale_destroy',
+  'ICU4XCollator_destroy',
+];
+
+void main(List<String> arguments) {
+  link(
+    arguments,
+    (config, output) async {
+      final staticLib = config.assets
+          .firstWhereOrNull((asset) => asset.id == 'package:$package/$assetId');
+      if (staticLib == null) {
+        // No static lib built, so assume a dynamic one was already bundled.
+        return;
+      }
+
+      final linker = CLinker.library(
+        name: config.packageName,
+        assetName: assetId,
+        sources: [staticLib.file!.path],
+        linkerOptions: LinkerOptions.treeshake(symbols: usedSymbols),
+      );
+
+      await linker.run(
+        config: config,
+        output: output,
+        logger: Logger('')
+          ..level = Level.ALL
+          ..onRecord.listen((record) => print(record.message)),
+      );
+
+      final postcard =
+          config.assets.firstWhere((asset) => asset.id.endsWith('postcard'));
+      final datagenTool =
+          config.assets.firstWhere((asset) => asset.id.endsWith('datagen'));
+      final dylib = output.assets.first;
+
+      await Process.run(datagenTool.file!.toFilePath(), [
+        '--locales',
+        (await _customLocales ?? locales).join(','),
+        '--input',
+        postcard.file!.toFilePath(),
+        '--keys-for-bin',
+        dylib.file!.toFilePath(),
+      ]);
+    },
+  );
+}
+
+Future<List<String>?> get _customLocales async {
+  final localPath = Platform.environment['ICU4X_LOCALE_LIST'];
+  if (localPath != null) {
+    final file = File(localPath);
+    if (await file.exists()) {
+      return file.readAsLines();
+    }
+  }
+  return null;
+}
diff --git a/pkgs/intl4x/lib/src/hook_helpers/locales.dart b/pkgs/intl4x/lib/src/hook_helpers/locales.dart
new file mode 100644
index 00000000..fe46aafd
--- /dev/null
+++ b/pkgs/intl4x/lib/src/hook_helpers/locales.dart
@@ -0,0 +1,5 @@
+// Copyright (c) 2024, 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.
+
+final locales = ['en_US'];
diff --git a/pkgs/intl4x/lib/src/hook_helpers/shared.dart b/pkgs/intl4x/lib/src/hook_helpers/shared.dart
new file mode 100644
index 00000000..6b00af73
--- /dev/null
+++ b/pkgs/intl4x/lib/src/hook_helpers/shared.dart
@@ -0,0 +1,6 @@
+// Copyright (c) 2024, 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.
+
+const package = 'intl4x';
+const assetId = 'src/bindings/lib.g.dart';
diff --git a/pkgs/intl4x/lib/src/locale/locale_native.dart b/pkgs/intl4x/lib/src/locale/locale_native.dart
index 377b67e7..589dcbc1 100644
--- a/pkgs/intl4x/lib/src/locale/locale_native.dart
+++ b/pkgs/intl4x/lib/src/locale/locale_native.dart
@@ -7,7 +7,7 @@ import 'locale.dart';
 /// This file should be replaced by references to ICU4X when ready.
 
 Locale parseLocaleWithSeparatorPlaceholder(String s, [String separator = '-']) {
-  final parsed = s.split(separator);
+  final parsed = s.split('.').first.split(separator);
   // ignore: unused_local_variable
   final subtags = parsed.skipWhile((value) => value != 'u').toList();
   final tags = parsed.takeWhile((value) => value != 'u').toList();
diff --git a/pkgs/intl4x/pubspec.yaml b/pkgs/intl4x/pubspec.yaml
index 833e3954..ecc0392c 100644
--- a/pkgs/intl4x/pubspec.yaml
+++ b/pkgs/intl4x/pubspec.yaml
@@ -20,8 +20,22 @@ dependencies:
   crypto: ^3.0.3
   ffi: ^2.1.0
   js: ^0.7.1
+  logging: ^1.2.0
   meta: ^1.12.0
-  native_assets_cli: ^0.7.2
+  native_assets_cli:
+    # path: ../../../native/pkgs/native_assets_cli
+    git: 
+      url: https://github.com/dart-lang/native.git
+      path: pkgs/native_assets_cli
+      ref: fixLinkerSomeMore
+
+  native_toolchain_c:
+    # path: ../../../native/pkgs/native_toolchain_c
+    git: 
+      url: https://github.com/dart-lang/native.git
+      path: pkgs/native_toolchain_c
+      ref: fixLinkerSomeMore
+      
   path: ^1.9.0
 
 dev_dependencies:

From e939c5a7df085f744856bdf060a2177b999c54d7 Mon Sep 17 00:00:00 2001
From: Moritz <mosum@google.com>
Date: Thu, 22 Aug 2024 15:42:34 +0200
Subject: [PATCH 02/16] Fix datagen filename

---
 pkgs/intl4x/hook/build.dart | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/pkgs/intl4x/hook/build.dart b/pkgs/intl4x/hook/build.dart
index 7ac5ffe3..dfa14bca 100644
--- a/pkgs/intl4x/hook/build.dart
+++ b/pkgs/intl4x/hook/build.dart
@@ -107,9 +107,10 @@ final class FetchMode extends BuildMode {
       config.outputDirectory.resolve(config.filename('icu4x')),
     );
 
+    final datagenName = config.targetOS.executableFileName('$target-datagen');
     final datagen = await fetchToFile(
       Uri.parse(
-          'https://github.com/dart-lang/i18n/releases/download/$version/$target-datagen'),
+          'https://github.com/dart-lang/i18n/releases/download/$version/$datagenName'),
       config.outputDirectory.resolve('datagen'),
     );
 

From a30bcbd29045bc1b2065963d1ce4c7f5ff26d497 Mon Sep 17 00:00:00 2001
From: Moritz <mosum@google.com>
Date: Thu, 22 Aug 2024 15:45:50 +0200
Subject: [PATCH 03/16] Add publish to none because of git deps

---
 pkgs/intl4x/pubspec.yaml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pkgs/intl4x/pubspec.yaml b/pkgs/intl4x/pubspec.yaml
index 531c1cfd..6831707a 100644
--- a/pkgs/intl4x/pubspec.yaml
+++ b/pkgs/intl4x/pubspec.yaml
@@ -13,6 +13,8 @@ platforms:
 topics:
   - i18n
 
+publish_to: none
+
 environment:
   sdk: ">=3.6.0-0 <4.0.0"
 

From bde4c53808770b1e779e088a7b6c8042f60a57d3 Mon Sep 17 00:00:00 2001
From: Moritz <mosum@google.com>
Date: Thu, 22 Aug 2024 15:51:04 +0200
Subject: [PATCH 04/16] Update env variable set

---
 .github/workflows/intl4x.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/intl4x.yml b/.github/workflows/intl4x.yml
index 13430fbd..428fe3d1 100644
--- a/.github/workflows/intl4x.yml
+++ b/.github/workflows/intl4x.yml
@@ -146,16 +146,16 @@ jobs:
         cd ../..
         dart run ffi/dart/tool/build_libs.dart bin/windows_x64 windows_x64 dynamic icu_collator,icu_datetime,icu_list,icu_decimal,icu_plurals,experimental_components,compiled_data
 
-    - run: echo "LOCAL_ICU4X_BINARY=$(realpath submodules/icu4x/bin/linux_x64)" >> $GITHUB_ENV
+    - run: echo "LOCAL_ICU4X_BINARY_DYNAMIC=$(realpath submodules/icu4x/bin/linux_x64)" >> $GITHUB_ENV
       if: matrix.os == 'ubuntu-latest'
 
-    - run: echo "LOCAL_ICU4X_BINARY=$(realpath submodules/icu4x/bin/macos_arm64)" >> $GITHUB_ENV
+    - run: echo "LOCAL_ICU4X_BINARY_DYNAMIC=$(realpath submodules/icu4x/bin/macos_arm64)" >> $GITHUB_ENV
       if: matrix.os == 'macos-latest'
     
-    - run: echo ("LOCAL_ICU4X_BINARY=" + (Get-Item submodules\icu4x\bin\windows_x64).FullName -replace '/', '\') >> $env:GITHUB_ENV
+    - run: echo ("LOCAL_ICU4X_BINARY_DYNAMIC=" + (Get-Item submodules\icu4x\bin\windows_x64).FullName -replace '/', '\') >> $env:GITHUB_ENV
       if: matrix.os == 'windows-latest'
 
-    - run: echo $LOCAL_ICU4X_BINARY
+    - run: echo $LOCAL_ICU4X_BINARY_DYNAMIC
           
     - name: Display structure of downloaded files
       run: ls -R

From 9d0061acdb68c6390d94999cc94f7f6602852c53 Mon Sep 17 00:00:00 2001
From: Moritz <mosum@google.com>
Date: Thu, 22 Aug 2024 18:12:26 +0200
Subject: [PATCH 05/16] Fix stuff

---
 .github/workflows/intl4x.yml |  54 ++++++++++++++-----
 pkgs/intl4x/hook/build.dart  | 101 +++++++++++++++++++++--------------
 2 files changed, 101 insertions(+), 54 deletions(-)

diff --git a/.github/workflows/intl4x.yml b/.github/workflows/intl4x.yml
index 428fe3d1..f571193d 100644
--- a/.github/workflows/intl4x.yml
+++ b/.github/workflows/intl4x.yml
@@ -32,9 +32,7 @@ jobs:
       matrix:
         sdk: [dev]
         os: [ubuntu-latest, windows-latest, macos-latest]
-        include:
-          - sdk: dev
-            run-tests: true
+
     steps:
       - uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9
         with:
@@ -42,20 +40,24 @@ jobs:
 
       - uses: dart-lang/setup-dart@0a8a0fc875eb934c15d08629302413c671d3f672
         with:
-          sdk: ${{matrix.sdk}}
+          sdk: ${{ matrix.sdk }}
 
       - run: dart --enable-experiment=native-assets pub get
 
       - run: dart --enable-experiment=native-assets analyze --fatal-infos
 
       - run: dart --enable-experiment=native-assets format --output=none --set-exit-if-changed .
-        if: ${{matrix.run-tests}}
 
       - run: dart --enable-experiment=native-assets test
-        if: ${{matrix.run-tests}}
 
       - run: dart --enable-experiment=native-assets test -p chrome
-        if: ${{matrix.run-tests}}
+
+      - name: Compile and run example
+        run: |
+          cd example_native
+          dart --enable-experiment=native-assets pub get
+          dart --enable-experiment=native-assets build bin/example_native.dart
+          ./bin/example_native.exe
 
   build_fetch:
     runs-on:  ${{ matrix.os }}
@@ -84,11 +86,19 @@ jobs:
 
       - run: dart --enable-experiment=native-assets test
 
+      - name: Compile and run example
+        run: |
+          cd example_native
+          dart --enable-experiment=native-assets pub get
+          dart --enable-experiment=native-assets build bin/example_native.dart
+          ./bin/example_native.exe
+
   build_local:
     strategy:
       fail-fast: false
       matrix:
         os: [ ubuntu-latest, macos-latest, windows-latest ]
+        compiletype: [ dynamic, static ]
     runs-on: ${{ matrix.os }}
 
     env:
@@ -120,7 +130,7 @@ jobs:
         cd ffi/dart
         dart pub get
         cd ../..
-        dart run ffi/dart/tool/build_libs.dart bin/linux_x64 linux_x64 dynamic icu_collator,icu_datetime,icu_list,icu_decimal,icu_plurals,experimental_components,compiled_data
+        dart run ffi/dart/tool/build_libs.dart bin/linux_x64 linux_x64 ${{ matrix.compiletype }} icu_collator,icu_datetime,icu_list,icu_decimal,icu_plurals,experimental_components,compiled_data
 
     - name: Build Mac
       if: matrix.os == 'macos-latest'
@@ -132,7 +142,7 @@ jobs:
         cd ffi/dart
         dart pub get
         cd ../..
-        dart run ffi/dart/tool/build_libs.dart bin/macos_arm64 macos_arm64 dynamic icu_collator,icu_datetime,icu_list,icu_decimal,icu_plurals,experimental_components,compiled_data
+        dart run ffi/dart/tool/build_libs.dart bin/macos_arm64 macos_arm64 ${{ matrix.compiletype }} icu_collator,icu_datetime,icu_list,icu_decimal,icu_plurals,experimental_components,compiled_data
 
     - name: Build Windows
       if: matrix.os == 'windows-latest'
@@ -144,18 +154,29 @@ jobs:
         cd ffi/dart
         dart pub get
         cd ../..
-        dart run ffi/dart/tool/build_libs.dart bin/windows_x64 windows_x64 dynamic icu_collator,icu_datetime,icu_list,icu_decimal,icu_plurals,experimental_components,compiled_data
+        dart run ffi/dart/tool/build_libs.dart bin/windows_x64 windows_x64 ${{ matrix.compiletype }} icu_collator,icu_datetime,icu_list,icu_decimal,icu_plurals,experimental_components,compiled_data
 
     - run: echo "LOCAL_ICU4X_BINARY_DYNAMIC=$(realpath submodules/icu4x/bin/linux_x64)" >> $GITHUB_ENV
-      if: matrix.os == 'ubuntu-latest'
+      if: matrix.os == 'ubuntu-latest' && ${{ matrix.compiletype }} == 'dynamic'
+
+    - run: echo "LOCAL_ICU4X_BINARY_STATIC=$(realpath submodules/icu4x/bin/linux_x64)" >> $GITHUB_ENV
+      if: matrix.os == 'ubuntu-latest' && ${{ matrix.compiletype }} == 'static'
 
     - run: echo "LOCAL_ICU4X_BINARY_DYNAMIC=$(realpath submodules/icu4x/bin/macos_arm64)" >> $GITHUB_ENV
-      if: matrix.os == 'macos-latest'
+      if: matrix.os == 'macos-latest' && ${{ matrix.compiletype }} == 'dynamic'
     
+    - run: echo "LOCAL_ICU4X_BINARY_STATIC=$(realpath submodules/icu4x/bin/macos_arm64)" >> $GITHUB_ENV
+      if: matrix.os == 'macos-latest' && ${{ matrix.compiletype }} == 'static'
+
     - run: echo ("LOCAL_ICU4X_BINARY_DYNAMIC=" + (Get-Item submodules\icu4x\bin\windows_x64).FullName -replace '/', '\') >> $env:GITHUB_ENV
-      if: matrix.os == 'windows-latest'
+      if: matrix.os == 'windows-latest' && ${{ matrix.compiletype }} == 'dynamic'
+      
+    - run: echo ("LOCAL_ICU4X_BINARY_STATIC=" + (Get-Item submodules\icu4x\bin\windows_x64).FullName -replace '/', '\') >> $env:GITHUB_ENV
+      if: matrix.os == 'windows-latest' && ${{ matrix.compiletype }} == 'static'
 
     - run: echo $LOCAL_ICU4X_BINARY_DYNAMIC
+    
+    - run: echo $LOCAL_ICU4X_BINARY_STATIC
           
     - name: Display structure of downloaded files
       run: ls -R
@@ -169,3 +190,10 @@ jobs:
       run: |
         cd pkgs/intl4x
         dart --enable-experiment=native-assets test
+
+    - name: Compile and run example
+      run: |
+        cd pkgs/intl4x/example_native
+        dart --enable-experiment=native-assets pub get
+        dart --enable-experiment=native-assets build bin/example_native.dart
+        ./bin/example_native.exe
diff --git a/pkgs/intl4x/hook/build.dart b/pkgs/intl4x/hook/build.dart
index dfa14bca..b682aa83 100644
--- a/pkgs/intl4x/hook/build.dart
+++ b/pkgs/intl4x/hook/build.dart
@@ -240,31 +240,16 @@ Future<BuildResult> buildLib(
   final datagenFileUri = config.outputDirectory.resolve('datagen');
   final postcardFileUri = config.outputDirectory.resolve('postcard');
   if (!config.dryRun) {
-    final rustTarget = _asRustTarget(
-      config.targetOS,
-      config.dryRun ? null : config.targetArchitecture!,
-      config.targetOS == OS.iOS &&
-          config.targetIOSSdk == IOSSdk.iPhoneSimulator,
-    );
     final isNoStd =
         _isNoStdTarget((config.targetOS, config.targetArchitecture));
 
     if (!isNoStd) {
-      final rustArguments = ['target', 'add', rustTarget];
-      final rustup = await Process.run(
+      final rustArguments = ['target', 'add', asRustTarget(config)];
+      await runProcess(
         'rustup',
         rustArguments,
         workingDirectory: workingDirectory,
       );
-
-      if (rustup.exitCode != 0) {
-        throw ProcessException(
-          'rustup',
-          rustArguments,
-          rustup.stderr.toString(),
-          rustup.exitCode,
-        );
-      }
     }
     final tempDir = await Directory.systemTemp.createTemp();
 
@@ -298,27 +283,18 @@ Future<BuildResult> buildLib(
       if (isNoStd) '--features=${noStdFeatures.join(',')}',
       if (isNoStd) '-Zbuild-std=core,alloc',
       if (isNoStd) '-Zbuild-std-features=panic_immediate_abort',
-      '--target=$rustTarget',
+      '--target=${asRustTarget(config)}',
       '--target-dir=${tempDir.path}'
     ];
-    final cargo = await Process.run(
+    await runProcess(
       'cargo',
       arguments,
       workingDirectory: workingDirectory,
     );
 
-    if (cargo.exitCode != 0) {
-      throw ProcessException(
-        'cargo',
-        arguments,
-        cargo.stderr.toString(),
-        cargo.exitCode,
-      );
-    }
-
     final builtPath = path.join(
       tempDir.path,
-      rustTarget,
+      asRustTarget(config),
       'release',
       libFileName,
     );
@@ -326,7 +302,7 @@ Future<BuildResult> buildLib(
 
     if (config.linkingEnabled) {
       final postcardPath = path.join(tempDir.path, 'full.postcard');
-      await Process.run(
+      await runProcess(
         'cargo',
         [
           'run',
@@ -341,26 +317,31 @@ Future<BuildResult> buildLib(
       );
       await copyFile(postcardPath, postcardFileUri);
 
-      final datagenPath = path.join(tempDir.path, 'datagen');
+      final datagenPath = path.join(
+        tempDir.path,
+        asRustTarget(config),
+        'release',
+        'icu4x-datagen',
+      );
       final datagenDirectory = path.join(workingDirectory, 'provider/datagen');
-      await Process.run(
+      await runProcess(
         'rustup',
-        ['target', 'add', 'aarch64-unknown-linux-gnu'],
+        ['target', 'add', asRustTarget(config)],
         workingDirectory: datagenDirectory,
       );
-      await Process.run(
+      await runProcess(
         'cargo',
         [
           'build',
           '--release',
-          '--bin',
-          'icu4x-datagen',
+          ...['--bin', 'icu4x-datagen'],
           '--no-default-features',
           ...[
             '--features',
             'bin,blob_exporter,blob_input,rayon,experimental_components'
           ],
-          ...['--target', 'aarch64-unknown-linux-gnu']
+          ...['--target', asRustTarget(config)],
+          '--target-dir=${tempDir.path}'
         ],
         workingDirectory: datagenDirectory,
       );
@@ -374,6 +355,15 @@ Future<BuildResult> buildLib(
   );
 }
 
+String asRustTarget(BuildConfig config) {
+  final rustTarget = _asRustTarget(
+    config.targetOS,
+    config.dryRun ? null : config.targetArchitecture!,
+    config.targetOS == OS.iOS && config.targetIOSSdk == IOSSdk.iPhoneSimulator,
+  );
+  return rustTarget;
+}
+
 String _asRustTarget(OS os, Architecture? architecture, bool isSimulator) {
   if (os == OS.iOS && architecture == Architecture.arm64 && isSimulator) {
     return 'aarch64-apple-ios-sim';
@@ -416,10 +406,39 @@ extension on BuildConfig {
       buildStatic ? targetOS.staticlibFileName : targetOS.dylibFileName;
 }
 
-Future<void> copyFile(String path, Uri libFileUri) async {
-  final file = File(path);
+Future<void> copyFile(String from, Uri to) async {
+  final file = File(from);
   if (!(await file.exists())) {
-    throw FileSystemException('File does not exist.', path);
+    throw FileSystemException('File does not exist.', from);
+  }
+  await file.copy(to.toFilePath(windows: Platform.isWindows));
+}
+
+Future<void> runProcess(
+  String executable,
+  List<String> arguments, {
+  required String workingDirectory,
+  bool dryRun = false,
+}) async {
+  print('----------');
+  print('Running `$executable $arguments` in $workingDirectory');
+  if (!dryRun) {
+    final processResult = await Process.run(
+      executable,
+      arguments,
+      workingDirectory: workingDirectory,
+    );
+    print('stdout:');
+    print(processResult.stdout);
+    if ((processResult.stderr as String).isNotEmpty) {
+      print('stderr:');
+      print(processResult.stderr);
+    }
+    if (processResult.exitCode != 0) {
+      throw ProcessException(executable, arguments, '', processResult.exitCode);
+    }
+  } else {
+    print('Not running, as --dry-run is set.');
   }
-  await file.copy(libFileUri.toFilePath(windows: Platform.isWindows));
+  print('==========');
 }

From ff73216398a736143a2de9a349ec18bb9c18e19c Mon Sep 17 00:00:00 2001
From: Moritz <mosum@google.com>
Date: Fri, 23 Aug 2024 09:58:43 +0200
Subject: [PATCH 06/16] Remove braces

---
 .github/workflows/intl4x.yml | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/intl4x.yml b/.github/workflows/intl4x.yml
index f571193d..f3e821f0 100644
--- a/.github/workflows/intl4x.yml
+++ b/.github/workflows/intl4x.yml
@@ -157,22 +157,22 @@ jobs:
         dart run ffi/dart/tool/build_libs.dart bin/windows_x64 windows_x64 ${{ matrix.compiletype }} icu_collator,icu_datetime,icu_list,icu_decimal,icu_plurals,experimental_components,compiled_data
 
     - run: echo "LOCAL_ICU4X_BINARY_DYNAMIC=$(realpath submodules/icu4x/bin/linux_x64)" >> $GITHUB_ENV
-      if: matrix.os == 'ubuntu-latest' && ${{ matrix.compiletype }} == 'dynamic'
+      if: matrix.os == 'ubuntu-latest' && matrix.compiletype == 'dynamic'
 
     - run: echo "LOCAL_ICU4X_BINARY_STATIC=$(realpath submodules/icu4x/bin/linux_x64)" >> $GITHUB_ENV
-      if: matrix.os == 'ubuntu-latest' && ${{ matrix.compiletype }} == 'static'
+      if: matrix.os == 'ubuntu-latest' && matrix.compiletype == 'static'
 
     - run: echo "LOCAL_ICU4X_BINARY_DYNAMIC=$(realpath submodules/icu4x/bin/macos_arm64)" >> $GITHUB_ENV
-      if: matrix.os == 'macos-latest' && ${{ matrix.compiletype }} == 'dynamic'
+      if: matrix.os == 'macos-latest' && matrix.compiletype == 'dynamic'
     
     - run: echo "LOCAL_ICU4X_BINARY_STATIC=$(realpath submodules/icu4x/bin/macos_arm64)" >> $GITHUB_ENV
-      if: matrix.os == 'macos-latest' && ${{ matrix.compiletype }} == 'static'
+      if: matrix.os == 'macos-latest' && matrix.compiletype == 'static'
 
     - run: echo ("LOCAL_ICU4X_BINARY_DYNAMIC=" + (Get-Item submodules\icu4x\bin\windows_x64).FullName -replace '/', '\') >> $env:GITHUB_ENV
-      if: matrix.os == 'windows-latest' && ${{ matrix.compiletype }} == 'dynamic'
+      if: matrix.os == 'windows-latest' && matrix.compiletype == 'dynamic'
       
     - run: echo ("LOCAL_ICU4X_BINARY_STATIC=" + (Get-Item submodules\icu4x\bin\windows_x64).FullName -replace '/', '\') >> $env:GITHUB_ENV
-      if: matrix.os == 'windows-latest' && ${{ matrix.compiletype }} == 'static'
+      if: matrix.os == 'windows-latest' && matrix.compiletype == 'static'
 
     - run: echo $LOCAL_ICU4X_BINARY_DYNAMIC
     

From 39b2434b63d4275a337cdcd1f1dec97086ebe468 Mon Sep 17 00:00:00 2001
From: Moritz <mosum@google.com>
Date: Fri, 23 Aug 2024 10:15:10 +0200
Subject: [PATCH 07/16] Add ifs

---
 .github/workflows/intl4x.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/intl4x.yml b/.github/workflows/intl4x.yml
index f3e821f0..c7297fc6 100644
--- a/.github/workflows/intl4x.yml
+++ b/.github/workflows/intl4x.yml
@@ -187,11 +187,13 @@ jobs:
         dart pub get
 
     - name: Run `dart test`
+      if: matrix.compiletype == 'dynamic'
       run: |
         cd pkgs/intl4x
         dart --enable-experiment=native-assets test
 
     - name: Compile and run example
+      if: matrix.compiletype == 'static'
       run: |
         cd pkgs/intl4x/example_native
         dart --enable-experiment=native-assets pub get

From 48e8fcdcfd61accb5c58d97b9bc7bc25ad8fe827 Mon Sep 17 00:00:00 2001
From: Moritz <mosum@google.com>
Date: Fri, 23 Aug 2024 10:19:39 +0200
Subject: [PATCH 08/16] Add more ifs

---
 .github/workflows/intl4x.yml | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/intl4x.yml b/.github/workflows/intl4x.yml
index c7297fc6..305cca7d 100644
--- a/.github/workflows/intl4x.yml
+++ b/.github/workflows/intl4x.yml
@@ -52,7 +52,9 @@ jobs:
 
       - run: dart --enable-experiment=native-assets test -p chrome
 
+    #TODO: Enable for windows and mac https://github.com/dart-lang/native/issues/1376
       - name: Compile and run example
+        if: matrix.os == 'ubuntu-latest'
         run: |
           cd example_native
           dart --enable-experiment=native-assets pub get
@@ -86,7 +88,9 @@ jobs:
 
       - run: dart --enable-experiment=native-assets test
 
+    #TODO: Enable for windows and mac https://github.com/dart-lang/native/issues/1376
       - name: Compile and run example
+        if: matrix.os == 'ubuntu-latest'
         run: |
           cd example_native
           dart --enable-experiment=native-assets pub get
@@ -192,8 +196,9 @@ jobs:
         cd pkgs/intl4x
         dart --enable-experiment=native-assets test
 
+    #TODO: Enable for windows and mac https://github.com/dart-lang/native/issues/1376
     - name: Compile and run example
-      if: matrix.compiletype == 'static'
+      if: matrix.os == 'ubuntu-latest' && matrix.compiletype == 'static' 
       run: |
         cd pkgs/intl4x/example_native
         dart --enable-experiment=native-assets pub get

From bf4cf652b520fb26d2c1304509939a497c8e43fb Mon Sep 17 00:00:00 2001
From: Moritz <mosum@google.com>
Date: Fri, 23 Aug 2024 10:40:04 +0200
Subject: [PATCH 09/16] Add chmod for datagen

---
 pkgs/intl4x/hook/build.dart                  | 29 ------------------
 pkgs/intl4x/hook/link.dart                   |  7 ++++-
 pkgs/intl4x/lib/src/hook_helpers/shared.dart | 31 ++++++++++++++++++++
 3 files changed, 37 insertions(+), 30 deletions(-)

diff --git a/pkgs/intl4x/hook/build.dart b/pkgs/intl4x/hook/build.dart
index b682aa83..bd249a26 100644
--- a/pkgs/intl4x/hook/build.dart
+++ b/pkgs/intl4x/hook/build.dart
@@ -413,32 +413,3 @@ Future<void> copyFile(String from, Uri to) async {
   }
   await file.copy(to.toFilePath(windows: Platform.isWindows));
 }
-
-Future<void> runProcess(
-  String executable,
-  List<String> arguments, {
-  required String workingDirectory,
-  bool dryRun = false,
-}) async {
-  print('----------');
-  print('Running `$executable $arguments` in $workingDirectory');
-  if (!dryRun) {
-    final processResult = await Process.run(
-      executable,
-      arguments,
-      workingDirectory: workingDirectory,
-    );
-    print('stdout:');
-    print(processResult.stdout);
-    if ((processResult.stderr as String).isNotEmpty) {
-      print('stderr:');
-      print(processResult.stderr);
-    }
-    if (processResult.exitCode != 0) {
-      throw ProcessException(executable, arguments, '', processResult.exitCode);
-    }
-  } else {
-    print('Not running, as --dry-run is set.');
-  }
-  print('==========');
-}
diff --git a/pkgs/intl4x/hook/link.dart b/pkgs/intl4x/hook/link.dart
index 60c65858..b3b2ffa0 100644
--- a/pkgs/intl4x/hook/link.dart
+++ b/pkgs/intl4x/hook/link.dart
@@ -65,7 +65,12 @@ void main(List<String> arguments) {
           config.assets.firstWhere((asset) => asset.id.endsWith('datagen'));
       final dylib = output.assets.first;
 
-      await Process.run(datagenTool.file!.toFilePath(), [
+      final datagen = datagenTool.file!.toFilePath();
+      if (OS.current == OS.linux) {
+        await runProcess('chmod', ['+x', datagen]);
+      }
+
+      await Process.run(datagen, [
         '--locales',
         (await _customLocales ?? locales).join(','),
         '--input',
diff --git a/pkgs/intl4x/lib/src/hook_helpers/shared.dart b/pkgs/intl4x/lib/src/hook_helpers/shared.dart
index 6b00af73..0e066455 100644
--- a/pkgs/intl4x/lib/src/hook_helpers/shared.dart
+++ b/pkgs/intl4x/lib/src/hook_helpers/shared.dart
@@ -2,5 +2,36 @@
 // 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:io';
+
 const package = 'intl4x';
 const assetId = 'src/bindings/lib.g.dart';
+
+Future<void> runProcess(
+  String executable,
+  List<String> arguments, {
+  String? workingDirectory,
+  bool dryRun = false,
+}) async {
+  print('----------');
+  print('Running `$executable $arguments` in $workingDirectory');
+  if (!dryRun) {
+    final processResult = await Process.run(
+      executable,
+      arguments,
+      workingDirectory: workingDirectory,
+    );
+    print('stdout:');
+    print(processResult.stdout);
+    if ((processResult.stderr as String).isNotEmpty) {
+      print('stderr:');
+      print(processResult.stderr);
+    }
+    if (processResult.exitCode != 0) {
+      throw ProcessException(executable, arguments, '', processResult.exitCode);
+    }
+  } else {
+    print('Not running, as --dry-run is set.');
+  }
+  print('==========');
+}

From 455a7db45ec6c48ce7368971651e2c5a275458b3 Mon Sep 17 00:00:00 2001
From: Moritz <mosum@google.com>
Date: Fri, 23 Aug 2024 11:05:44 +0200
Subject: [PATCH 10/16] Add hashes for datagen

---
 pkgs/intl4x/hook/README.md                   |  2 +-
 pkgs/intl4x/hook/build.dart                  | 48 ++++++++++++--------
 pkgs/intl4x/hook/link.dart                   |  1 +
 pkgs/intl4x/lib/src/hook_helpers/hashes.dart | 15 +++++-
 pkgs/intl4x/tool/regenerate_hashes.dart      | 47 ++++++++++++++-----
 5 files changed, 81 insertions(+), 32 deletions(-)

diff --git a/pkgs/intl4x/hook/README.md b/pkgs/intl4x/hook/README.md
index a0fdcb44..d9e5dfe0 100644
--- a/pkgs/intl4x/hook/README.md
+++ b/pkgs/intl4x/hook/README.md
@@ -10,5 +10,5 @@
 1. Create PR.
 2. Run `bash tools/regenerate_bindings.sh`, and fix resulting errors.
 3. Update `const version` in `version.dart` to tag.
-4. Regenerate hashes using `cd pkgs/intl4x/; dart --enable-experiment=native-assets run tool/regenerate_hashes.dart`.
+4. Regenerate hashes using `cd pkgs/intl4x/; dart --enable-experiment=native-assets tool/regenerate_hashes.dart`.
 5. Land PR.
diff --git a/pkgs/intl4x/hook/build.dart b/pkgs/intl4x/hook/build.dart
index bd249a26..b35fbe1b 100644
--- a/pkgs/intl4x/hook/build.dart
+++ b/pkgs/intl4x/hook/build.dart
@@ -107,35 +107,47 @@ final class FetchMode extends BuildMode {
       config.outputDirectory.resolve(config.filename('icu4x')),
     );
 
+    final bytes = await library.readAsBytes();
+    final fileHash = sha256.convert(bytes).toString();
+    final expectedFileHash =
+        fileHashes[(config.targetOS, config.targetArchitecture, libraryType)];
+    if (fileHash != expectedFileHash) {
+      throw Exception(
+          'The pre-built binary for the target $target at $dylibRemoteUri has a'
+          ' hash of $fileHash, which does not match $expectedFileHash fixed in'
+          ' the build hook of package:intl4x.');
+    }
+
     final datagenName = config.targetOS.executableFileName('$target-datagen');
+    final datagenUri = Uri.parse(
+        'https://github.com/dart-lang/i18n/releases/download/$version/$datagenName');
     final datagen = await fetchToFile(
-      Uri.parse(
-          'https://github.com/dart-lang/i18n/releases/download/$version/$datagenName'),
+      datagenUri,
       config.outputDirectory.resolve('datagen'),
     );
 
+    final datagenBytes = await datagen.readAsBytes();
+    final datagenHash = sha256.convert(datagenBytes).toString();
+    final expectedDatagenHash =
+        datagenHashes[(config.targetOS, config.targetArchitecture)];
+    if (datagenHash != expectedDatagenHash) {
+      throw Exception(
+          'The pre-built binary for the target $target at $datagenUri has a'
+          ' hash of $datagenHash, which does not match $expectedDatagenHash '
+          'fixed in the build hook of package:intl4x.');
+    }
+
     final postcard = await fetchToFile(
       Uri.parse(
           'https://github.com/dart-lang/i18n/releases/download/$version/full.postcard'),
       config.outputDirectory.resolve('full.postcard'),
     );
 
-    final bytes = await library.readAsBytes();
-    final fileHash = sha256.convert(bytes).toString();
-    final expectedFileHash =
-        fileHashes[(config.targetOS, config.targetArchitecture, libraryType)];
-    if (fileHash == expectedFileHash) {
-      return BuildResult(
-        library: library.uri,
-        datagen: datagen.uri,
-        postcard: postcard.uri,
-      );
-    } else {
-      throw Exception(
-          'The pre-built binary for the target $target at $dylibRemoteUri has a'
-          ' hash of $fileHash, which does not match $expectedFileHash fixed in'
-          ' the build hook of package:intl4x.');
-    }
+    return BuildResult(
+      library: library.uri,
+      datagen: datagen.uri,
+      postcard: postcard.uri,
+    );
   }
 
   Future<File> fetchToFile(Uri uri, Uri fileUri) async {
diff --git a/pkgs/intl4x/hook/link.dart b/pkgs/intl4x/hook/link.dart
index b3b2ffa0..8e183960 100644
--- a/pkgs/intl4x/hook/link.dart
+++ b/pkgs/intl4x/hook/link.dart
@@ -66,6 +66,7 @@ void main(List<String> arguments) {
       final dylib = output.assets.first;
 
       final datagen = datagenTool.file!.toFilePath();
+
       if (OS.current == OS.linux) {
         await runProcess('chmod', ['+x', datagen]);
       }
diff --git a/pkgs/intl4x/lib/src/hook_helpers/hashes.dart b/pkgs/intl4x/lib/src/hook_helpers/hashes.dart
index a186c969..4a4776ad 100644
--- a/pkgs/intl4x/lib/src/hook_helpers/hashes.dart
+++ b/pkgs/intl4x/lib/src/hook_helpers/hashes.dart
@@ -4,7 +4,7 @@
 
 // THIS FILE IS AUTOGENERATED BY `tool/regenerate_hashes.dart`. TO UPDATE, RUN
 //
-//    dart --enable-experiment=native-assets run tool/regenerate_hashes.dart
+//    dart --enable-experiment=native-assets tool/regenerate_hashes.dart
 //
 
 import 'package:native_assets_cli/native_assets_cli.dart';
@@ -75,3 +75,16 @@ const fileHashes = <(OS, Architecture, String), String>{
   (OS.iOS, Architecture.x64, 'static'):
       '6e4e4072126b3017c6a532575a165d1a80b2bccb59a24108682483935c98ff19'
 };
+
+const datagenHashes = <(OS, Architecture), String>{
+  (OS.linux, Architecture.arm64):
+      'b44dd95e9622f84552dd0599028bd867cdf3f14a1c3d807a39a710a3f2e3e491',
+  (OS.linux, Architecture.riscv64):
+      'fdee9c86eb6d8abad33c1ec2a343dc3b66ffd54412a448a38be2b17ea1d28241',
+  (OS.linux, Architecture.x64):
+      '10add51f8739a7e87907a1453f58c6fc268b06489bd1d51502e142db7e33eb28',
+  (OS.macOS, Architecture.arm64):
+      '019fb83b2a59f366afc21dea30b69ebaa65f16026cd55c57075617c6ca89c61e',
+  (OS.macOS, Architecture.x64):
+      '31908391cecd0c842bf9489e08eec57ccdaa5b82ad2f887e316303938011f0b7'
+};
diff --git a/pkgs/intl4x/tool/regenerate_hashes.dart b/pkgs/intl4x/tool/regenerate_hashes.dart
index 713f20d7..101f4b9b 100644
--- a/pkgs/intl4x/tool/regenerate_hashes.dart
+++ b/pkgs/intl4x/tool/regenerate_hashes.dart
@@ -9,21 +9,21 @@ final httpClient = HttpClient();
 Future<void> main(List<String> args) async {
   print('Checking hashes for $version');
   final fileHashes = <(String, Architecture, String), String>{};
-  final dynamicLibrary = File.fromUri(Directory.systemTemp.uri.resolve('lib'));
-  await dynamicLibrary.create();
+  final datagenHashes = <(String, Architecture), String>{};
+  final file = File.fromUri(Directory.systemTemp.uri.resolve('lib'));
+  await file.create();
   for (final os in ['linux', 'windows', 'fuchsia', 'android', 'macOS', 'iOS']) {
     for (final architecture in Architecture.values) {
+      final target = '${os}_$architecture-datagen';
+      final datagenHash = await getHash(target, file);
+      if (datagenHash != null) {
+        datagenHashes[(os, architecture)] = datagenHash;
+      }
       for (final libraryType in ['dynamic', 'static']) {
-        final target = [os, architecture, libraryType].join('_');
-        print('Checking hash for $target');
-        final success = await _fetchLibrary(target, httpClient, dynamicLibrary);
-        if (success) {
-          final bytes = await dynamicLibrary.readAsBytes();
-          final fileHash = sha256.convert(bytes).toString();
+        final target = '${os}_${architecture}_$libraryType';
+        final fileHash = await getHash(target, file);
+        if (fileHash != null) {
           fileHashes[(os, architecture, libraryType)] = fileHash;
-          print('Hash is $fileHash');
-        } else {
-          print('Could not fetch library');
         }
       }
     }
@@ -37,7 +37,7 @@ Future<void> main(List<String> args) async {
 
 // THIS FILE IS AUTOGENERATED BY `tool/regenerate_hashes.dart`. TO UPDATE, RUN
 //
-//    dart --enable-experiment=native-assets run tool/regenerate_hashes.dart
+//    dart --enable-experiment=native-assets tool/regenerate_hashes.dart
 //
 
 import 'package:native_assets_cli/native_assets_cli.dart';
@@ -50,9 +50,32 @@ ${fileHashes.map((key, value) => MapEntry(
             (e) => '  ${e.key}:\n      ${e.value}',
           ).join(',\n')}
 };
+
+const datagenHashes = <(OS, Architecture), String>{
+${datagenHashes.map((key, value) => MapEntry(
+                ('OS.${key.$1}', 'Architecture.${key.$2}'),
+                "'$value'",
+              )).entries.map(
+            (e) => '  ${e.key}:\n      ${e.value}',
+          ).join(',\n')}
+};
 ''');
 }
 
+Future<String?> getHash(String target, File dynamicLibrary) async {
+  print('Checking hash for $target');
+  final success = await _fetchLibrary(target, httpClient, dynamicLibrary);
+  if (success) {
+    final bytes = await dynamicLibrary.readAsBytes();
+    final fileHash = sha256.convert(bytes).toString();
+    print('Hash is $fileHash');
+    return fileHash;
+  } else {
+    print('Could not fetch library');
+    return null;
+  }
+}
+
 Future<bool> _fetchLibrary(
     String target, HttpClient httpClient, File dynamicLibrary) async {
   final uri = Uri.parse(

From 15f69c76f165770ad03044c30f16c030cfcccd87 Mon Sep 17 00:00:00 2001
From: Moritz <mosum@google.com>
Date: Fri, 23 Aug 2024 12:42:59 +0200
Subject: [PATCH 11/16] Fix path in wf

---
 .github/workflows/intl4x.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/intl4x.yml b/.github/workflows/intl4x.yml
index 305cca7d..bd2c94ef 100644
--- a/.github/workflows/intl4x.yml
+++ b/.github/workflows/intl4x.yml
@@ -59,7 +59,7 @@ jobs:
           cd example_native
           dart --enable-experiment=native-assets pub get
           dart --enable-experiment=native-assets build bin/example_native.dart
-          ./bin/example_native.exe
+          ./bin/example_native/example_native.exe
 
   build_fetch:
     runs-on:  ${{ matrix.os }}
@@ -95,7 +95,7 @@ jobs:
           cd example_native
           dart --enable-experiment=native-assets pub get
           dart --enable-experiment=native-assets build bin/example_native.dart
-          ./bin/example_native.exe
+          ./bin/example_native/example_native.exe
 
   build_local:
     strategy:
@@ -203,4 +203,4 @@ jobs:
         cd pkgs/intl4x/example_native
         dart --enable-experiment=native-assets pub get
         dart --enable-experiment=native-assets build bin/example_native.dart
-        ./bin/example_native.exe
+        ./bin/example_native/example_native.exe

From 541b3e803e735b36be2a6db521ca82f871e20937 Mon Sep 17 00:00:00 2001
From: Moritz <mosum@google.com>
Date: Fri, 23 Aug 2024 12:48:15 +0200
Subject: [PATCH 12/16] Add license header

---
 pkgs/intl4x/example_native/bin/example_native.dart | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/pkgs/intl4x/example_native/bin/example_native.dart b/pkgs/intl4x/example_native/bin/example_native.dart
index 72e1dd04..6ad7b6b2 100644
--- a/pkgs/intl4x/example_native/bin/example_native.dart
+++ b/pkgs/intl4x/example_native/bin/example_native.dart
@@ -1,3 +1,7 @@
+// Copyright (c) 2024, 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:intl4x/intl4x.dart';
 
 void main(List<String> arguments) {

From e4bf6292c890a59122f3d78d9756effe1e4a827d Mon Sep 17 00:00:00 2001
From: Moritz <mosum@google.com>
Date: Fri, 23 Aug 2024 12:55:15 +0200
Subject: [PATCH 13/16] Add datagen and postcard file gen

---
 .github/workflows/intl4x.yml | 59 ++++++++++++++++++++++++++++++------
 1 file changed, 50 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/intl4x.yml b/.github/workflows/intl4x.yml
index bd2c94ef..399ecc7c 100644
--- a/.github/workflows/intl4x.yml
+++ b/.github/workflows/intl4x.yml
@@ -135,6 +135,15 @@ jobs:
         dart pub get
         cd ../..
         dart run ffi/dart/tool/build_libs.dart bin/linux_x64 linux_x64 ${{ matrix.compiletype }} icu_collator,icu_datetime,icu_list,icu_decimal,icu_plurals,experimental_components,compiled_data
+        
+        cargo run -p icu_datagen -- --locales full --keys all --format blob --out bin/full.postcard
+
+        cd provider/datagen # avoid global feature resolution
+        rustup target add x86_64-unknown-linux-gnu
+        cargo build --release --bin icu4x-datagen --no-default-features --features bin,blob_exporter,blob_input,rayon,experimental_components --target x86_64-unknown-linux-gnu
+        cd ../..
+
+        cp target/x86_64-unknown-linux-gnu/release/icu4x-datagen bin/linux_x64-datagen
 
     - name: Build Mac
       if: matrix.os == 'macos-latest'
@@ -147,6 +156,15 @@ jobs:
         dart pub get
         cd ../..
         dart run ffi/dart/tool/build_libs.dart bin/macos_arm64 macos_arm64 ${{ matrix.compiletype }} icu_collator,icu_datetime,icu_list,icu_decimal,icu_plurals,experimental_components,compiled_data
+        
+        cargo run -p icu_datagen -- --locales full --keys all --format blob --out bin/full.postcard
+
+        cd provider/datagen # avoid global feature resolution
+        rustup target add x86_64-apple-darwin
+        cargo build --release --bin icu4x-datagen --no-default-features --features bin,blob_exporter,blob_input,rayon,experimental_components --target x86_64-apple-darwin
+        cd ../..
+
+        cp target/x86_64-apple-darwin/release/icu4x-datagen bin/macos_x64-datagen
 
     - name: Build Windows
       if: matrix.os == 'windows-latest'
@@ -159,28 +177,51 @@ jobs:
         dart pub get
         cd ../..
         dart run ffi/dart/tool/build_libs.dart bin/windows_x64 windows_x64 ${{ matrix.compiletype }} icu_collator,icu_datetime,icu_list,icu_decimal,icu_plurals,experimental_components,compiled_data
+        
+        cargo run -p icu_datagen -- --locales full --keys all --format blob --out bin/full.postcard
+
+        cd provider/datagen # avoid global feature resolution
+        rustup target add x86_64-pc-windows-msvc
+        cargo build --release --bin icu4x-datagen --no-default-features --features bin,blob_exporter,blob_input,rayon,experimental_components --target x86_64-pc-windows-msvc
+        cd ../..
 
-    - run: echo "LOCAL_ICU4X_BINARY_DYNAMIC=$(realpath submodules/icu4x/bin/linux_x64)" >> $GITHUB_ENV
+        cp target/x86_64-pc-windows-msvc/release/icu4x-datagen.exe bin/windows_x64-datagen.exe
+
+    - run: |
+        echo "LOCAL_ICU4X_BINARY_DYNAMIC=$(realpath submodules/icu4x/bin/linux_x64)" >> $GITHUB_ENV
       if: matrix.os == 'ubuntu-latest' && matrix.compiletype == 'dynamic'
 
-    - run: echo "LOCAL_ICU4X_BINARY_STATIC=$(realpath submodules/icu4x/bin/linux_x64)" >> $GITHUB_ENV
+    - run: |
+        echo "LOCAL_ICU4X_BINARY_STATIC=$(realpath submodules/icu4x/bin/linux_x64)" >> $GITHUB_ENV
+        echo "LOCAL_ICU4X_DATAGEN=$(realpath submodules/icu4x/bin/linux_x64-datagen)" >> $GITHUB_ENV
+        echo "LOCAL_ICU4X_POSTCARD=$(realpath submodules/icu4x/bin/full.postcard)" >> $GITHUB_ENV
       if: matrix.os == 'ubuntu-latest' && matrix.compiletype == 'static'
 
-    - run: echo "LOCAL_ICU4X_BINARY_DYNAMIC=$(realpath submodules/icu4x/bin/macos_arm64)" >> $GITHUB_ENV
+    - run: |
+        echo "LOCAL_ICU4X_BINARY_DYNAMIC=$(realpath submodules/icu4x/bin/macos_arm64)" >> $GITHUB_ENV
       if: matrix.os == 'macos-latest' && matrix.compiletype == 'dynamic'
     
-    - run: echo "LOCAL_ICU4X_BINARY_STATIC=$(realpath submodules/icu4x/bin/macos_arm64)" >> $GITHUB_ENV
+    - run: |
+        echo "LOCAL_ICU4X_BINARY_STATIC=$(realpath submodules/icu4x/bin/macos_arm64)" >> $GITHUB_ENV
+        echo "LOCAL_ICU4X_DATAGEN=$(realpath submodules/icu4x/bin/macos_x64-datagen)" >> $GITHUB_ENV
+        echo "LOCAL_ICU4X_POSTCARD=$(realpath submodules/icu4x/bin/full.postcard)" >> $GITHUB_ENV
       if: matrix.os == 'macos-latest' && matrix.compiletype == 'static'
 
-    - run: echo ("LOCAL_ICU4X_BINARY_DYNAMIC=" + (Get-Item submodules\icu4x\bin\windows_x64).FullName -replace '/', '\') >> $env:GITHUB_ENV
+    - run: |
+        echo ("LOCAL_ICU4X_BINARY_DYNAMIC=" + (Get-Item submodules\icu4x\bin\windows_x64).FullName -replace '/', '\') >> $env:GITHUB_ENV
       if: matrix.os == 'windows-latest' && matrix.compiletype == 'dynamic'
       
-    - run: echo ("LOCAL_ICU4X_BINARY_STATIC=" + (Get-Item submodules\icu4x\bin\windows_x64).FullName -replace '/', '\') >> $env:GITHUB_ENV
+    - run: |
+        echo ("LOCAL_ICU4X_BINARY_STATIC=" + (Get-Item submodules\icu4x\bin\windows_x64).FullName -replace '/', '\') >> $env:GITHUB_ENV
+        echo ("LOCAL_ICU4X_DATAGEN=" + (Get-Item submodules\icu4x\bin\windows_x64-datagen.exe).FullName -replace '/', '\') >> $env:GITHUB_ENV
+        echo ("LOCAL_ICU4X_POSTCARD=" + (Get-Item submodules\icu4x\bin\full.postcard).FullName -replace '/', '\') >> $env:GITHUB_ENV
       if: matrix.os == 'windows-latest' && matrix.compiletype == 'static'
 
-    - run: echo $LOCAL_ICU4X_BINARY_DYNAMIC
-    
-    - run: echo $LOCAL_ICU4X_BINARY_STATIC
+    - run: |
+        echo $LOCAL_ICU4X_BINARY_DYNAMIC
+        echo $LOCAL_ICU4X_BINARY_STATIC
+        echo $LOCAL_ICU4X_DATAGEN
+        echo $LOCAL_ICU4X_POSTCARD
           
     - name: Display structure of downloaded files
       run: ls -R

From d9ff7bd66ceb1a3e796bd8371f2b21e857b059d0 Mon Sep 17 00:00:00 2001
From: Moritz <mosum@google.com>
Date: Mon, 26 Aug 2024 09:32:09 +0200
Subject: [PATCH 14/16] Add locale to example

---
 pkgs/intl4x/example_native/bin/example_native.dart | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkgs/intl4x/example_native/bin/example_native.dart b/pkgs/intl4x/example_native/bin/example_native.dart
index 6ad7b6b2..3426a405 100644
--- a/pkgs/intl4x/example_native/bin/example_native.dart
+++ b/pkgs/intl4x/example_native/bin/example_native.dart
@@ -5,6 +5,6 @@
 import 'package:intl4x/intl4x.dart';
 
 void main(List<String> arguments) {
-  final intl = Intl();
+  final intl = Intl(locale: Locale(language: 'en'));
   print('collation: ${intl.collation().compare('a', 'b')}!');
 }

From 856fba04ecf4421b6baff7d175a24cde8043d6dd Mon Sep 17 00:00:00 2001
From: Moritz <mosum@google.com>
Date: Mon, 26 Aug 2024 10:24:13 +0200
Subject: [PATCH 15/16] Fix windows hashes

---
 pkgs/intl4x/lib/src/hook_helpers/hashes.dart | 4 ++++
 pkgs/intl4x/tool/regenerate_hashes.dart      | 4 +++-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/pkgs/intl4x/lib/src/hook_helpers/hashes.dart b/pkgs/intl4x/lib/src/hook_helpers/hashes.dart
index 4a4776ad..31c1fa47 100644
--- a/pkgs/intl4x/lib/src/hook_helpers/hashes.dart
+++ b/pkgs/intl4x/lib/src/hook_helpers/hashes.dart
@@ -83,6 +83,10 @@ const datagenHashes = <(OS, Architecture), String>{
       'fdee9c86eb6d8abad33c1ec2a343dc3b66ffd54412a448a38be2b17ea1d28241',
   (OS.linux, Architecture.x64):
       '10add51f8739a7e87907a1453f58c6fc268b06489bd1d51502e142db7e33eb28',
+  (OS.windows, Architecture.arm64):
+      'e7be9f8a484a4c86003d4eb6310b9ad7d4af688d2581048f421c08c324ded2b8',
+  (OS.windows, Architecture.x64):
+      'c09dae71c4031447513b5393a876d7a5481afc02bbcedcc8edb06561c96a3929',
   (OS.macOS, Architecture.arm64):
       '019fb83b2a59f366afc21dea30b69ebaa65f16026cd55c57075617c6ca89c61e',
   (OS.macOS, Architecture.x64):
diff --git a/pkgs/intl4x/tool/regenerate_hashes.dart b/pkgs/intl4x/tool/regenerate_hashes.dart
index 101f4b9b..ca084651 100644
--- a/pkgs/intl4x/tool/regenerate_hashes.dart
+++ b/pkgs/intl4x/tool/regenerate_hashes.dart
@@ -14,7 +14,9 @@ Future<void> main(List<String> args) async {
   await file.create();
   for (final os in ['linux', 'windows', 'fuchsia', 'android', 'macOS', 'iOS']) {
     for (final architecture in Architecture.values) {
-      final target = '${os}_$architecture-datagen';
+      final target = OS.values
+          .firstWhere((value) => value.toString() == os.toLowerCase())
+          .executableFileName('${os}_$architecture-datagen');
       final datagenHash = await getHash(target, file);
       if (datagenHash != null) {
         datagenHashes[(os, architecture)] = datagenHash;

From 5e62169db4f21e8f15466d87dc6d6009278bc7c5 Mon Sep 17 00:00:00 2001
From: Moritz <mosum@google.com>
Date: Mon, 23 Sep 2024 16:48:12 -0400
Subject: [PATCH 16/16] Updates

---
 pkgs/intl4x/example_native/pubspec.yaml       |   2 -
 pkgs/intl4x/hook/build.dart                   | 282 +++++++++---------
 pkgs/intl4x/hook/link.dart                    |  75 +++--
 .../lib/src/bindings/AnyCalendarKind.g.dart   |   6 +-
 .../lib/src/bindings/Bcp47ToIanaMapper.g.dart |   6 +-
 pkgs/intl4x/lib/src/bindings/Bidi.g.dart      |  16 +-
 pkgs/intl4x/lib/src/bindings/BidiInfo.g.dart  |  10 +-
 .../lib/src/bindings/BidiParagraph.g.dart     |  16 +-
 pkgs/intl4x/lib/src/bindings/Calendar.g.dart  |   8 +-
 .../CanonicalCombiningClassMap.g.dart         |   6 +-
 .../src/bindings/CanonicalComposition.g.dart  |   6 +-
 .../bindings/CanonicalDecomposition.g.dart    |   6 +-
 .../lib/src/bindings/CaseMapCloser.g.dart     |   8 +-
 .../intl4x/lib/src/bindings/CaseMapper.g.dart |  27 +-
 .../src/bindings/CodePointMapData16.g.dart    |  13 +-
 .../lib/src/bindings/CodePointMapData8.g.dart |  35 ++-
 .../bindings/CodePointRangeIterator.g.dart    |   4 +-
 .../src/bindings/CodePointSetBuilder.g.dart   |  34 +--
 .../lib/src/bindings/CodePointSetData.g.dart  | 147 +++++----
 pkgs/intl4x/lib/src/bindings/Collator.g.dart  |   8 +-
 .../src/bindings/ComposingNormalizer.g.dart   |  10 +-
 .../lib/src/bindings/CustomTimeZone.g.dart    |  54 ++--
 .../lib/src/bindings/DataProvider.g.dart      |  16 +-
 pkgs/intl4x/lib/src/bindings/Date.g.dart      |  36 +--
 .../lib/src/bindings/DateFormatter.g.dart     |  12 +-
 pkgs/intl4x/lib/src/bindings/DateTime.g.dart  |  50 ++--
 .../lib/src/bindings/DateTimeFormatter.g.dart |   8 +-
 .../src/bindings/DecomposingNormalizer.g.dart |  10 +-
 .../lib/src/bindings/FixedDecimal.g.dart      |  85 +++---
 .../src/bindings/FixedDecimalFormatter.g.dart |   7 +-
 .../GeneralCategoryNameToMaskMapper.g.dart    |   8 +-
 .../GraphemeClusterBreakIteratorLatin1.g.dart |   4 +-
 .../GraphemeClusterBreakIteratorUtf16.g.dart  |   4 +-
 .../GraphemeClusterBreakIteratorUtf8.g.dart   |   4 +-
 .../bindings/GraphemeClusterSegmenter.g.dart  |   6 +-
 .../bindings/GregorianDateFormatter.g.dart    |   8 +-
 .../GregorianDateTimeFormatter.g.dart         |   6 +-
 .../GregorianZonedDateTimeFormatter.g.dart    |   9 +-
 .../lib/src/bindings/IanaToBcp47Mapper.g.dart |   6 +-
 pkgs/intl4x/lib/src/bindings/IsoDate.g.dart   |  32 +-
 .../lib/src/bindings/IsoDateTime.g.dart       |  51 ++--
 .../bindings/LineBreakIteratorLatin1.g.dart   |   4 +-
 .../bindings/LineBreakIteratorUtf16.g.dart    |   4 +-
 .../src/bindings/LineBreakIteratorUtf8.g.dart |   4 +-
 .../lib/src/bindings/LineSegmenter.g.dart     |  16 +-
 .../lib/src/bindings/ListFormatter.g.dart     |  10 +-
 pkgs/intl4x/lib/src/bindings/Locale.g.dart    |  34 +--
 .../src/bindings/LocaleCanonicalizer.g.dart   |   8 +-
 .../src/bindings/LocaleDirectionality.g.dart  |  12 +-
 .../LocaleDisplayNamesFormatter.g.dart        |   6 +-
 .../lib/src/bindings/LocaleExpander.g.dart    |  12 +-
 .../bindings/LocaleFallbackIterator.g.dart    |   4 +-
 .../lib/src/bindings/LocaleFallbacker.g.dart  |   8 +-
 .../LocaleFallbackerWithConfig.g.dart         |   4 +-
 pkgs/intl4x/lib/src/bindings/Logger.g.dart    |   6 +-
 .../lib/src/bindings/MeasureUnit.g.dart       |   2 +-
 .../lib/src/bindings/MeasureUnitParser.g.dart |   4 +-
 .../src/bindings/MetazoneCalculator.g.dart    |   4 +-
 .../lib/src/bindings/PluralCategory.g.dart    |   2 +-
 .../lib/src/bindings/PluralOperands.g.dart    |   6 +-
 .../lib/src/bindings/PluralRules.g.dart       |  10 +-
 .../PropertyValueNameToEnumMapper.g.dart      |  32 +-
 .../src/bindings/RegionDisplayNames.g.dart    |   6 +-
 .../lib/src/bindings/ReorderedIndexMap.g.dart |  10 +-
 .../src/bindings/ScriptExtensionsSet.g.dart   |   8 +-
 .../src/bindings/ScriptWithExtensions.g.dart  |  12 +-
 .../ScriptWithExtensionsBorrowed.g.dart       |  12 +-
 .../lib/src/bindings/SegmenterWordType.g.dart |   2 +-
 .../SentenceBreakIteratorLatin1.g.dart        |   4 +-
 .../SentenceBreakIteratorUtf16.g.dart         |   4 +-
 .../bindings/SentenceBreakIteratorUtf8.g.dart |   4 +-
 .../lib/src/bindings/SentenceSegmenter.g.dart |   6 +-
 pkgs/intl4x/lib/src/bindings/Time.g.dart      |  14 +-
 .../lib/src/bindings/TimeFormatter.g.dart     |  10 +-
 .../lib/src/bindings/TimeZoneFormatter.g.dart |  30 +-
 .../lib/src/bindings/TimeZoneIdMapper.g.dart  |  12 +-
 ...oneIdMapperWithFastCanonicalization.g.dart |  10 +-
 .../lib/src/bindings/TitlecaseMapper.g.dart   |   6 +-
 .../lib/src/bindings/TitlecaseOptions.g.dart  |   2 +-
 .../lib/src/bindings/UnicodeSetData.g.dart    |  18 +-
 .../lib/src/bindings/UnitsConverter.g.dart    |   6 +-
 .../src/bindings/UnitsConverterFactory.g.dart |   8 +-
 .../lib/src/bindings/WeekCalculator.g.dart    |  12 +-
 .../bindings/WordBreakIteratorLatin1.g.dart   |   8 +-
 .../bindings/WordBreakIteratorUtf16.g.dart    |   8 +-
 .../src/bindings/WordBreakIteratorUtf8.g.dart |   8 +-
 .../lib/src/bindings/WordSegmenter.g.dart     |  10 +-
 .../bindings/ZonedDateTimeFormatter.g.dart    |  11 +-
 pkgs/intl4x/lib/src/bindings/lib.g.dart       |  19 +-
 .../lib/src/collation/collation_impl.dart     |   3 -
 .../datetime_format/datetime_format_impl.dart |   3 -
 .../src/display_names/display_names_impl.dart |   3 -
 .../lib/src/list_format/list_format_impl.dart |   3 -
 pkgs/intl4x/lib/src/locale/locale.dart        |   2 -
 .../src/number_format/number_format_impl.dart |   3 -
 .../src/plural_rules/plural_rules_impl.dart   |   3 -
 pkgs/intl4x/pubspec.yaml                      |  21 +-
 97 files changed, 807 insertions(+), 827 deletions(-)

diff --git a/pkgs/intl4x/example_native/pubspec.yaml b/pkgs/intl4x/example_native/pubspec.yaml
index 00fc43be..0eef732b 100644
--- a/pkgs/intl4x/example_native/pubspec.yaml
+++ b/pkgs/intl4x/example_native/pubspec.yaml
@@ -1,7 +1,5 @@
 name: example_native
 description: A sample command-line application.
-version: 1.0.0
-# repository: https://github.com/my_org/my_repo
 
 publish_to: none
 
diff --git a/pkgs/intl4x/hook/build.dart b/pkgs/intl4x/hook/build.dart
index b35fbe1b..cf5e589d 100644
--- a/pkgs/intl4x/hook/build.dart
+++ b/pkgs/intl4x/hook/build.dart
@@ -74,13 +74,13 @@ final class BuildResult {
           os: config.targetOS,
           file: library,
         ),
-        if (datagen != null)
+        if (config.linkingEnabled)
           DataAsset(
             package: package,
             name: 'datagen',
             file: datagen!,
           ),
-        if (postcard != null)
+        if (config.linkingEnabled)
           DataAsset(
             package: package,
             name: 'postcard',
@@ -118,12 +118,20 @@ final class FetchMode extends BuildMode {
           ' the build hook of package:intl4x.');
     }
 
+    if (!config.linkingEnabled) {
+      return BuildResult(
+        library: library.uri,
+        datagen: null,
+        postcard: null,
+      );
+    }
     final datagenName = config.targetOS.executableFileName('$target-datagen');
-    final datagenUri = Uri.parse(
+    final datagenRemote = Uri.parse(
         'https://github.com/dart-lang/i18n/releases/download/$version/$datagenName');
+    final datagenUri = config.outputDirectory.resolve('datagen');
     final datagen = await fetchToFile(
+      datagenRemote,
       datagenUri,
-      config.outputDirectory.resolve('datagen'),
     );
 
     final datagenBytes = await datagen.readAsBytes();
@@ -132,21 +140,21 @@ final class FetchMode extends BuildMode {
         datagenHashes[(config.targetOS, config.targetArchitecture)];
     if (datagenHash != expectedDatagenHash) {
       throw Exception(
-          'The pre-built binary for the target $target at $datagenUri has a'
+          'The pre-built binary for the target $target at $datagenRemote has a'
           ' hash of $datagenHash, which does not match $expectedDatagenHash '
           'fixed in the build hook of package:intl4x.');
     }
 
-    final postcard = await fetchToFile(
+    final postcardUri = config.outputDirectory.resolve('full.postcard');
+    await fetchToFile(
       Uri.parse(
           'https://github.com/dart-lang/i18n/releases/download/$version/full.postcard'),
-      config.outputDirectory.resolve('full.postcard'),
+      postcardUri,
     );
-
     return BuildResult(
       library: library.uri,
-      datagen: datagen.uri,
-      postcard: postcard.uri,
+      datagen: datagenUri,
+      postcard: postcardUri,
     );
   }
 
@@ -176,8 +184,10 @@ final class LocalMode extends BuildMode {
           'LOCAL_ICU4X_BINARY_${config.linkingEnabled ? 'STATIC' : 'DYNAMIC'}',
           true,
         )!,
-        localDatagenPath = _getFromEnvironment('LOCAL_ICU4X_DATAGEN', false),
-        localPostcardPath = _getFromEnvironment('LOCAL_ICU4X_POSTCARD', false);
+        localDatagenPath =
+            _getFromEnvironment('LOCAL_ICU4X_DATAGEN', config.linkingEnabled),
+        localPostcardPath =
+            _getFromEnvironment('LOCAL_ICU4X_POSTCARD', config.linkingEnabled);
 
   static String? _getFromEnvironment(String key, bool mustExist) {
     final localPath = Platform.environment[key];
@@ -194,21 +204,19 @@ final class LocalMode extends BuildMode {
     final libFileUri = config.outputDirectory.resolve(config.filename('icu4x'));
     await copyFile(localLibraryPath, libFileUri);
 
-    final Uri? datagenFileUri;
-    if (localDatagenPath != null) {
-      datagenFileUri = config.outputDirectory.resolve('datagen');
-      await copyFile(localDatagenPath!, datagenFileUri);
-    } else {
-      datagenFileUri = null;
+    if (!config.linkingEnabled) {
+      return BuildResult(
+        library: libFileUri,
+        datagen: null,
+        postcard: null,
+      );
     }
 
-    final Uri? postcardFileUri;
-    if (localPostcardPath != null) {
-      postcardFileUri = config.outputDirectory.resolve('postcard');
-      await copyFile(localPostcardPath!, postcardFileUri);
-    } else {
-      postcardFileUri = null;
-    }
+    final datagenFileUri = config.outputDirectory.resolve('datagen');
+    await copyFile(localDatagenPath!, datagenFileUri);
+
+    final postcardFileUri = config.outputDirectory.resolve('postcard');
+    await copyFile(localPostcardPath!, postcardFileUri);
 
     return BuildResult(
       library: libFileUri,
@@ -218,9 +226,7 @@ final class LocalMode extends BuildMode {
   }
 
   @override
-  List<Uri> get dependencies => [
-        Uri.file(localLibraryPath),
-      ];
+  List<Uri> get dependencies => [Uri.file(localLibraryPath)];
 }
 
 final class CheckoutMode extends BuildMode {
@@ -251,119 +257,129 @@ Future<BuildResult> buildLib(
   final libFileUri = config.outputDirectory.resolve(libFileName);
   final datagenFileUri = config.outputDirectory.resolve('datagen');
   final postcardFileUri = config.outputDirectory.resolve('postcard');
-  if (!config.dryRun) {
-    final isNoStd =
-        _isNoStdTarget((config.targetOS, config.targetArchitecture));
-
-    if (!isNoStd) {
-      final rustArguments = ['target', 'add', asRustTarget(config)];
-      await runProcess(
-        'rustup',
-        rustArguments,
-        workingDirectory: workingDirectory,
-      );
-    }
-    final tempDir = await Directory.systemTemp.createTemp();
-
-    final stdFeatures = [
-      'icu_collator,icu_datetime,icu_list,icu_decimal,icu_plurals',
-      'compiled_data',
-      'buffer_provider',
-      'logging',
-      'simple_logger',
-      'experimental_components',
-    ];
-    final noStdFeatures = [
-      'icu_collator,icu_datetime,icu_list,icu_decimal,icu_plurals',
-      'compiled_data',
-      'buffer_provider',
-      'libc-alloc',
-      'panic-handler',
-      'experimental_components',
-    ];
-    final linkModeType = config.buildStatic ? 'staticlib' : 'cdylib';
-    final arguments = [
-      if (isNoStd) '+nightly',
-      'rustc',
-      '-p=$crateName',
-      '--crate-type=$linkModeType',
-      '--release',
-      '--config=profile.release.panic="abort"',
-      '--config=profile.release.codegen-units=1',
-      '--no-default-features',
-      if (!isNoStd) '--features=${stdFeatures.join(',')}',
-      if (isNoStd) '--features=${noStdFeatures.join(',')}',
-      if (isNoStd) '-Zbuild-std=core,alloc',
-      if (isNoStd) '-Zbuild-std-features=panic_immediate_abort',
-      '--target=${asRustTarget(config)}',
-      '--target-dir=${tempDir.path}'
-    ];
+  if (config.dryRun) {
+    return BuildResult(
+      library: libFileUri,
+      datagen: datagenFileUri,
+      postcard: postcardFileUri,
+    );
+  }
+  final isNoStd = _isNoStdTarget((config.targetOS, config.targetArchitecture));
+
+  if (!isNoStd) {
+    final rustArguments = ['target', 'add', asRustTarget(config)];
     await runProcess(
-      'cargo',
-      arguments,
+      'rustup',
+      rustArguments,
       workingDirectory: workingDirectory,
     );
+  }
+  final tempDir = await Directory.systemTemp.createTemp();
+
+  final stdFeatures = [
+    'icu_collator,icu_datetime,icu_list,icu_decimal,icu_plurals',
+    'compiled_data',
+    'buffer_provider',
+    'logging',
+    'simple_logger',
+    'experimental_components',
+  ];
+  final noStdFeatures = [
+    'icu_collator,icu_datetime,icu_list,icu_decimal,icu_plurals',
+    'compiled_data',
+    'buffer_provider',
+    'libc-alloc',
+    'panic-handler',
+    'experimental_components',
+  ];
+  final linkModeType = config.buildStatic ? 'staticlib' : 'cdylib';
+  final arguments = [
+    if (isNoStd) '+nightly',
+    'rustc',
+    '-p=$crateName',
+    '--crate-type=$linkModeType',
+    '--release',
+    '--config=profile.release.panic="abort"',
+    '--config=profile.release.codegen-units=1',
+    '--no-default-features',
+    if (!isNoStd) '--features=${stdFeatures.join(',')}',
+    if (isNoStd) '--features=${noStdFeatures.join(',')}',
+    if (isNoStd) '-Zbuild-std=core,alloc',
+    if (isNoStd) '-Zbuild-std-features=panic_immediate_abort',
+    '--target=${asRustTarget(config)}',
+    '--target-dir=${tempDir.path}'
+  ];
+  await runProcess(
+    'cargo',
+    arguments,
+    workingDirectory: workingDirectory,
+  );
 
-    final builtPath = path.join(
-      tempDir.path,
-      asRustTarget(config),
-      'release',
-      libFileName,
-    );
-    await copyFile(builtPath, libFileUri);
-
-    if (config.linkingEnabled) {
-      final postcardPath = path.join(tempDir.path, 'full.postcard');
-      await runProcess(
-        'cargo',
-        [
-          'run',
-          ...['-p', 'icu_datagen'],
-          '--',
-          ...['--locales', 'full'],
-          ...['--keys', 'all'],
-          ...['--format', 'blob'],
-          ...['--out', postcardPath],
-        ],
-        workingDirectory: workingDirectory,
-      );
-      await copyFile(postcardPath, postcardFileUri);
+  final builtPath = path.join(
+    tempDir.path,
+    asRustTarget(config),
+    'release',
+    libFileName,
+  );
+  await copyFile(builtPath, libFileUri);
 
-      final datagenPath = path.join(
-        tempDir.path,
-        asRustTarget(config),
-        'release',
-        'icu4x-datagen',
-      );
-      final datagenDirectory = path.join(workingDirectory, 'provider/datagen');
-      await runProcess(
-        'rustup',
-        ['target', 'add', asRustTarget(config)],
-        workingDirectory: datagenDirectory,
-      );
-      await runProcess(
-        'cargo',
-        [
-          'build',
-          '--release',
-          ...['--bin', 'icu4x-datagen'],
-          '--no-default-features',
-          ...[
-            '--features',
-            'bin,blob_exporter,blob_input,rayon,experimental_components'
-          ],
-          ...['--target', asRustTarget(config)],
-          '--target-dir=${tempDir.path}'
-        ],
-        workingDirectory: datagenDirectory,
-      );
-      await copyFile(datagenPath, datagenFileUri);
-    }
+  if (!config.linkingEnabled) {
+    return BuildResult(
+      library: libFileUri,
+      datagen: null,
+      postcard: null,
+    );
   }
+
+  final postcardPath = path.join(tempDir.path, 'full.postcard');
+  await runProcess(
+    'cargo',
+    [
+      'run',
+      ...['-p', 'icu_datagen'],
+      '--',
+      ...['--locales', 'full'],
+      ...['--keys', 'all'],
+      ...['--format', 'blob'],
+      ...['--out', postcardPath],
+    ],
+    workingDirectory: workingDirectory,
+  );
+  await copyFile(postcardPath, postcardFileUri);
+
+  final datagenPath = path.join(
+    tempDir.path,
+    asRustTarget(config),
+    'release',
+    'icu4x-datagen',
+  );
+  final datagenDirectory = path.join(workingDirectory, 'provider/datagen');
+  await runProcess(
+    'rustup',
+    ['target', 'add', asRustTarget(config)],
+    workingDirectory: datagenDirectory,
+  );
+  await runProcess(
+    'cargo',
+    [
+      'build',
+      '--release',
+      ...['--bin', 'icu4x-datagen'],
+      '--no-default-features',
+      ...[
+        '--features',
+        'bin,blob_exporter,blob_input,rayon,experimental_components'
+      ],
+      ...['--target', asRustTarget(config)],
+      '--target-dir=${tempDir.path}'
+    ],
+    workingDirectory: datagenDirectory,
+  );
+  await copyFile(datagenPath, datagenFileUri);
   return BuildResult(
     library: libFileUri,
-    datagen: config.linkingEnabled ? datagenFileUri : null,
-    postcard: config.linkingEnabled ? postcardFileUri : null,
+    datagen: datagenFileUri,
+    postcard: postcardFileUri,
   );
 }
 
diff --git a/pkgs/intl4x/hook/link.dart b/pkgs/intl4x/hook/link.dart
index 8e183960..372fadc8 100644
--- a/pkgs/intl4x/hook/link.dart
+++ b/pkgs/intl4x/hook/link.dart
@@ -1,6 +1,7 @@
 // Copyright (c) 2024, 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 'dart:convert';
 import 'dart:io';
 
 import 'package:collection/collection.dart';
@@ -9,30 +10,35 @@ import 'package:intl4x/src/hook_helpers/shared.dart';
 import 'package:logging/logging.dart';
 import 'package:native_assets_cli/native_assets_cli.dart';
 import 'package:native_toolchain_c/native_toolchain_c.dart';
+import 'package:record_use/record_use.dart';
 
 // TODO(mosuem): Use `record_use` to automagically get the used symbols.
-const usedSymbols = <String>[
-  'diplomat_buffer_writeable_create',
-  'diplomat_buffer_writeable_get_bytes',
-  'diplomat_buffer_writeable_len',
-  'diplomat_buffer_writeable_destroy',
-  'ICU4XCollator_create_v1',
-  'ICU4XCollator_compare_utf16_',
-  'ICU4XDataProvider_create_compiled',
-  'ICU4XDataProvider_create_empty',
-  'ICU4XLocale_create_und',
-  'ICU4XLocale_set_language',
-  'ICU4XLocale_set_region',
-  'ICU4XLocale_set_script',
-  'ICU4XLocale_to_string',
-  'ICU4XLocale_total_cmp_',
-  //additional
-  'ICU4XDataProvider_create_compiled',
-  'ICU4XDataProvider_destroy',
-  'ICU4XLocale_destroy',
-  'ICU4XCollator_destroy',
-];
+// const usedSymbolsOld = <String>[
+//   'diplomat_buffer_writeable_create',
+//   'diplomat_buffer_writeable_get_bytes',
+//   'diplomat_buffer_writeable_len',
+//   'diplomat_buffer_writeable_destroy',
+//   'ICU4XCollator_create_v1',
+//   'ICU4XCollator_compare_utf16_',
+//   'ICU4XDataProvider_create_compiled',
+//   'ICU4XDataProvider_create_empty',
+//   'ICU4XLocale_create_und',
+//   'ICU4XLocale_set_language',
+//   'ICU4XLocale_set_region',
+//   'ICU4XLocale_set_script',
+//   'ICU4XLocale_to_string',
+//   'ICU4XLocale_total_cmp_',
+//   //additional
+//   'ICU4XDataProvider_create_compiled',
+//   'ICU4XDataProvider_destroy',
+//   'ICU4XLocale_destroy',
+//   'ICU4XCollator_destroy',
+// ];
 
+const keepSymbolId = Identifier(
+  importUri: 'package:intl4x/src/bindings/lib.g.dart',
+  name: 'KeepSymbol',
+);
 void main(List<String> arguments) {
   link(
     arguments,
@@ -44,13 +50,17 @@ void main(List<String> arguments) {
         return;
       }
 
+      final usedSymbols = config.usages.instancesOf(keepSymbolId)!.map(
+          (instance) =>
+              // Get the "symbol" field value from "KeepSymbol"
+              (instance.instanceConstant.fields.values.first as StringConstant)
+                  .value);
       final linker = CLinker.library(
         name: config.packageName,
         assetName: assetId,
         sources: [staticLib.file!.path],
         linkerOptions: LinkerOptions.treeshake(symbols: usedSymbols),
       );
-
       await linker.run(
         config: config,
         output: output,
@@ -58,12 +68,14 @@ void main(List<String> arguments) {
           ..level = Level.ALL
           ..onRecord.listen((record) => print(record.message)),
       );
+      final dylib = output.assets.last;
 
-      final postcard =
-          config.assets.firstWhere((asset) => asset.id.endsWith('postcard'));
-      final datagenTool =
-          config.assets.firstWhere((asset) => asset.id.endsWith('datagen'));
-      final dylib = output.assets.first;
+      final postcard = config.assets
+          .whereType<DataAsset>()
+          .firstWhere((asset) => asset.name == 'postcard');
+      final datagenTool = config.assets
+          .whereType<DataAsset>()
+          .firstWhere((asset) => asset.name == 'datagen');
 
       final datagen = datagenTool.file!.toFilePath();
 
@@ -93,3 +105,12 @@ Future<List<String>?> get _customLocales async {
   }
   return null;
 }
+
+extension on LinkConfig {
+  RecordedUsages get usages {
+    final usagesFile = recordedUsagesFile;
+    final usagesContent = File.fromUri(usagesFile!).readAsStringSync();
+    final usagesJson = jsonDecode(usagesContent) as Map<String, dynamic>;
+    return RecordedUsages.fromJson(usagesJson);
+  }
+}
diff --git a/pkgs/intl4x/lib/src/bindings/AnyCalendarKind.g.dart b/pkgs/intl4x/lib/src/bindings/AnyCalendarKind.g.dart
index c6e32996..97f693d8 100644
--- a/pkgs/intl4x/lib/src/bindings/AnyCalendarKind.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/AnyCalendarKind.g.dart
@@ -106,21 +106,21 @@ enum AnyCalendarKind {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XAnyCalendarKind_get_for_locale')
+@KeepSymbol('ICU4XAnyCalendarKind_get_for_locale')
 @ffi.Native<_ResultInt32Void Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XAnyCalendarKind_get_for_locale')
 // ignore: non_constant_identifier_names
 external _ResultInt32Void _ICU4XAnyCalendarKind_get_for_locale(
     ffi.Pointer<ffi.Opaque> locale);
 
-@meta.ResourceIdentifier('ICU4XAnyCalendarKind_get_for_bcp47')
+@KeepSymbol('ICU4XAnyCalendarKind_get_for_bcp47')
 @ffi.Native<_ResultInt32Void Function(ffi.Pointer<ffi.Uint8>, ffi.Size)>(
     isLeaf: true, symbol: 'ICU4XAnyCalendarKind_get_for_bcp47')
 // ignore: non_constant_identifier_names
 external _ResultInt32Void _ICU4XAnyCalendarKind_get_for_bcp47(
     ffi.Pointer<ffi.Uint8> sData, int sLength);
 
-@meta.ResourceIdentifier('ICU4XAnyCalendarKind_bcp47')
+@KeepSymbol('ICU4XAnyCalendarKind_bcp47')
 @ffi.Native<_ResultVoidInt32 Function(ffi.Int32, ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XAnyCalendarKind_bcp47')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/Bcp47ToIanaMapper.g.dart b/pkgs/intl4x/lib/src/bindings/Bcp47ToIanaMapper.g.dart
index 60f3c545..9a911e3a 100644
--- a/pkgs/intl4x/lib/src/bindings/Bcp47ToIanaMapper.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/Bcp47ToIanaMapper.g.dart
@@ -55,20 +55,20 @@ final class Bcp47ToIanaMapper implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XBcp47ToIanaMapper_destroy')
+@KeepSymbol('ICU4XBcp47ToIanaMapper_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XBcp47ToIanaMapper_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XBcp47ToIanaMapper_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XBcp47ToIanaMapper_create')
+@KeepSymbol('ICU4XBcp47ToIanaMapper_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XBcp47ToIanaMapper_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XBcp47ToIanaMapper_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XBcp47ToIanaMapper_get')
+@KeepSymbol('ICU4XBcp47ToIanaMapper_get')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Uint8>, ffi.Size, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/Bidi.g.dart b/pkgs/intl4x/lib/src/bindings/Bidi.g.dart
index ad36faaa..8b5ade1d 100644
--- a/pkgs/intl4x/lib/src/bindings/Bidi.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/Bidi.g.dart
@@ -109,19 +109,19 @@ final class Bidi implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XBidi_destroy')
+@KeepSymbol('ICU4XBidi_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XBidi_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XBidi_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XBidi_create')
+@KeepSymbol('ICU4XBidi_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XBidi_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XBidi_create(ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XBidi_for_text_valid_utf8')
+@KeepSymbol('ICU4XBidi_for_text_valid_utf8')
 @ffi.Native<
     ffi.Pointer<ffi.Opaque> Function(
         ffi.Pointer<ffi.Opaque>,
@@ -135,7 +135,7 @@ external ffi.Pointer<ffi.Opaque> _ICU4XBidi_for_text_valid_utf8(
     int textLength,
     int defaultLevel);
 
-@meta.ResourceIdentifier('ICU4XBidi_reorder_visual')
+@KeepSymbol('ICU4XBidi_reorder_visual')
 @ffi.Native<
     ffi.Pointer<ffi.Opaque> Function(
         ffi.Pointer<ffi.Opaque>,
@@ -147,24 +147,24 @@ external ffi.Pointer<ffi.Opaque> _ICU4XBidi_reorder_visual(
     ffi.Pointer<ffi.Uint8> levelsData,
     int levelsLength);
 
-@meta.ResourceIdentifier('ICU4XBidi_level_is_rtl')
+@KeepSymbol('ICU4XBidi_level_is_rtl')
 @ffi.Native<ffi.Bool Function(ffi.Uint8)>(
     isLeaf: true, symbol: 'ICU4XBidi_level_is_rtl')
 // ignore: non_constant_identifier_names
 external bool _ICU4XBidi_level_is_rtl(int level);
 
-@meta.ResourceIdentifier('ICU4XBidi_level_is_ltr')
+@KeepSymbol('ICU4XBidi_level_is_ltr')
 @ffi.Native<ffi.Bool Function(ffi.Uint8)>(
     isLeaf: true, symbol: 'ICU4XBidi_level_is_ltr')
 // ignore: non_constant_identifier_names
 external bool _ICU4XBidi_level_is_ltr(int level);
 
-@meta.ResourceIdentifier('ICU4XBidi_level_rtl')
+@KeepSymbol('ICU4XBidi_level_rtl')
 @ffi.Native<ffi.Uint8 Function()>(isLeaf: true, symbol: 'ICU4XBidi_level_rtl')
 // ignore: non_constant_identifier_names
 external int _ICU4XBidi_level_rtl();
 
-@meta.ResourceIdentifier('ICU4XBidi_level_ltr')
+@KeepSymbol('ICU4XBidi_level_ltr')
 @ffi.Native<ffi.Uint8 Function()>(isLeaf: true, symbol: 'ICU4XBidi_level_ltr')
 // ignore: non_constant_identifier_names
 external int _ICU4XBidi_level_ltr();
diff --git a/pkgs/intl4x/lib/src/bindings/BidiInfo.g.dart b/pkgs/intl4x/lib/src/bindings/BidiInfo.g.dart
index 11f5de41..d16ee790 100644
--- a/pkgs/intl4x/lib/src/bindings/BidiInfo.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/BidiInfo.g.dart
@@ -60,19 +60,19 @@ final class BidiInfo implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XBidiInfo_destroy')
+@KeepSymbol('ICU4XBidiInfo_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XBidiInfo_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XBidiInfo_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XBidiInfo_paragraph_count')
+@KeepSymbol('ICU4XBidiInfo_paragraph_count')
 @ffi.Native<ffi.Size Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XBidiInfo_paragraph_count')
 // ignore: non_constant_identifier_names
 external int _ICU4XBidiInfo_paragraph_count(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XBidiInfo_paragraph_at')
+@KeepSymbol('ICU4XBidiInfo_paragraph_at')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>, ffi.Size)>(
     isLeaf: true, symbol: 'ICU4XBidiInfo_paragraph_at')
@@ -80,13 +80,13 @@ external int _ICU4XBidiInfo_paragraph_count(ffi.Pointer<ffi.Opaque> self);
 external ffi.Pointer<ffi.Opaque> _ICU4XBidiInfo_paragraph_at(
     ffi.Pointer<ffi.Opaque> self, int n);
 
-@meta.ResourceIdentifier('ICU4XBidiInfo_size')
+@KeepSymbol('ICU4XBidiInfo_size')
 @ffi.Native<ffi.Size Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XBidiInfo_size')
 // ignore: non_constant_identifier_names
 external int _ICU4XBidiInfo_size(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XBidiInfo_level_at')
+@KeepSymbol('ICU4XBidiInfo_level_at')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>, ffi.Size)>(
     isLeaf: true, symbol: 'ICU4XBidiInfo_level_at')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/BidiParagraph.g.dart b/pkgs/intl4x/lib/src/bindings/BidiParagraph.g.dart
index 3d49b0d4..a8bfe117 100644
--- a/pkgs/intl4x/lib/src/bindings/BidiParagraph.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/BidiParagraph.g.dart
@@ -96,44 +96,44 @@ final class BidiParagraph implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XBidiParagraph_destroy')
+@KeepSymbol('ICU4XBidiParagraph_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XBidiParagraph_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XBidiParagraph_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XBidiParagraph_set_paragraph_in_text')
+@KeepSymbol('ICU4XBidiParagraph_set_paragraph_in_text')
 @ffi.Native<_ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>, ffi.Size)>(
     isLeaf: true, symbol: 'ICU4XBidiParagraph_set_paragraph_in_text')
 // ignore: non_constant_identifier_names
 external _ResultVoidInt32 _ICU4XBidiParagraph_set_paragraph_in_text(
     ffi.Pointer<ffi.Opaque> self, int n);
 
-@meta.ResourceIdentifier('ICU4XBidiParagraph_direction')
+@KeepSymbol('ICU4XBidiParagraph_direction')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XBidiParagraph_direction')
 // ignore: non_constant_identifier_names
 external int _ICU4XBidiParagraph_direction(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XBidiParagraph_size')
+@KeepSymbol('ICU4XBidiParagraph_size')
 @ffi.Native<ffi.Size Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XBidiParagraph_size')
 // ignore: non_constant_identifier_names
 external int _ICU4XBidiParagraph_size(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XBidiParagraph_range_start')
+@KeepSymbol('ICU4XBidiParagraph_range_start')
 @ffi.Native<ffi.Size Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XBidiParagraph_range_start')
 // ignore: non_constant_identifier_names
 external int _ICU4XBidiParagraph_range_start(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XBidiParagraph_range_end')
+@KeepSymbol('ICU4XBidiParagraph_range_end')
 @ffi.Native<ffi.Size Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XBidiParagraph_range_end')
 // ignore: non_constant_identifier_names
 external int _ICU4XBidiParagraph_range_end(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XBidiParagraph_reorder_line')
+@KeepSymbol('ICU4XBidiParagraph_reorder_line')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>, ffi.Size, ffi.Size,
             ffi.Pointer<ffi.Opaque>)>(
@@ -145,7 +145,7 @@ external _ResultVoidInt32 _ICU4XBidiParagraph_reorder_line(
     int rangeEnd,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XBidiParagraph_level_at')
+@KeepSymbol('ICU4XBidiParagraph_level_at')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>, ffi.Size)>(
     isLeaf: true, symbol: 'ICU4XBidiParagraph_level_at')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/Calendar.g.dart b/pkgs/intl4x/lib/src/bindings/Calendar.g.dart
index 4bc1fb27..3947b656 100644
--- a/pkgs/intl4x/lib/src/bindings/Calendar.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/Calendar.g.dart
@@ -58,13 +58,13 @@ final class Calendar implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XCalendar_destroy')
+@KeepSymbol('ICU4XCalendar_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XCalendar_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XCalendar_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XCalendar_create_for_locale')
+@KeepSymbol('ICU4XCalendar_create_for_locale')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -73,14 +73,14 @@ external void _ICU4XCalendar_destroy(ffi.Pointer<ffi.Void> self);
 external _ResultOpaqueInt32 _ICU4XCalendar_create_for_locale(
     ffi.Pointer<ffi.Opaque> provider, ffi.Pointer<ffi.Opaque> locale);
 
-@meta.ResourceIdentifier('ICU4XCalendar_create_for_kind')
+@KeepSymbol('ICU4XCalendar_create_for_kind')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XCalendar_create_for_kind')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCalendar_create_for_kind(
     ffi.Pointer<ffi.Opaque> provider, int kind);
 
-@meta.ResourceIdentifier('ICU4XCalendar_kind')
+@KeepSymbol('ICU4XCalendar_kind')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCalendar_kind')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/CanonicalCombiningClassMap.g.dart b/pkgs/intl4x/lib/src/bindings/CanonicalCombiningClassMap.g.dart
index 78c367c9..9259b60a 100644
--- a/pkgs/intl4x/lib/src/bindings/CanonicalCombiningClassMap.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/CanonicalCombiningClassMap.g.dart
@@ -47,21 +47,21 @@ final class CanonicalCombiningClassMap implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XCanonicalCombiningClassMap_destroy')
+@KeepSymbol('ICU4XCanonicalCombiningClassMap_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XCanonicalCombiningClassMap_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XCanonicalCombiningClassMap_destroy(
     ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XCanonicalCombiningClassMap_create')
+@KeepSymbol('ICU4XCanonicalCombiningClassMap_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCanonicalCombiningClassMap_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCanonicalCombiningClassMap_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCanonicalCombiningClassMap_get')
+@KeepSymbol('ICU4XCanonicalCombiningClassMap_get')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCanonicalCombiningClassMap_get')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/CanonicalComposition.g.dart b/pkgs/intl4x/lib/src/bindings/CanonicalComposition.g.dart
index 98aff8fc..5a8f45b9 100644
--- a/pkgs/intl4x/lib/src/bindings/CanonicalComposition.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/CanonicalComposition.g.dart
@@ -50,20 +50,20 @@ final class CanonicalComposition implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XCanonicalComposition_destroy')
+@KeepSymbol('ICU4XCanonicalComposition_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XCanonicalComposition_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XCanonicalComposition_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XCanonicalComposition_create')
+@KeepSymbol('ICU4XCanonicalComposition_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCanonicalComposition_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCanonicalComposition_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCanonicalComposition_compose')
+@KeepSymbol('ICU4XCanonicalComposition_compose')
 @ffi.Native<
         ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCanonicalComposition_compose')
diff --git a/pkgs/intl4x/lib/src/bindings/CanonicalDecomposition.g.dart b/pkgs/intl4x/lib/src/bindings/CanonicalDecomposition.g.dart
index f027f348..d2c9306c 100644
--- a/pkgs/intl4x/lib/src/bindings/CanonicalDecomposition.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/CanonicalDecomposition.g.dart
@@ -49,20 +49,20 @@ final class CanonicalDecomposition implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XCanonicalDecomposition_destroy')
+@KeepSymbol('ICU4XCanonicalDecomposition_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XCanonicalDecomposition_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XCanonicalDecomposition_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XCanonicalDecomposition_create')
+@KeepSymbol('ICU4XCanonicalDecomposition_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCanonicalDecomposition_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCanonicalDecomposition_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCanonicalDecomposition_decompose')
+@KeepSymbol('ICU4XCanonicalDecomposition_decompose')
 @ffi.Native<_DecomposedFfi Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCanonicalDecomposition_decompose')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/CaseMapCloser.g.dart b/pkgs/intl4x/lib/src/bindings/CaseMapCloser.g.dart
index b2de635d..d42f6cf1 100644
--- a/pkgs/intl4x/lib/src/bindings/CaseMapCloser.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/CaseMapCloser.g.dart
@@ -60,20 +60,20 @@ final class CaseMapCloser implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XCaseMapCloser_destroy')
+@KeepSymbol('ICU4XCaseMapCloser_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XCaseMapCloser_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XCaseMapCloser_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XCaseMapCloser_create')
+@KeepSymbol('ICU4XCaseMapCloser_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCaseMapCloser_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCaseMapCloser_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCaseMapCloser_add_case_closure_to')
+@KeepSymbol('ICU4XCaseMapCloser_add_case_closure_to')
 @ffi.Native<
         ffi.Void Function(
             ffi.Pointer<ffi.Opaque>, ffi.Uint32, ffi.Pointer<ffi.Opaque>)>(
@@ -82,7 +82,7 @@ external _ResultOpaqueInt32 _ICU4XCaseMapCloser_create(
 external void _ICU4XCaseMapCloser_add_case_closure_to(
     ffi.Pointer<ffi.Opaque> self, Rune c, ffi.Pointer<ffi.Opaque> builder);
 
-@meta.ResourceIdentifier('ICU4XCaseMapCloser_add_string_case_closure_to')
+@KeepSymbol('ICU4XCaseMapCloser_add_string_case_closure_to')
 @ffi.Native<
         ffi.Bool Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>,
             ffi.Size, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/CaseMapper.g.dart b/pkgs/intl4x/lib/src/bindings/CaseMapper.g.dart
index 2f9b7014..4d9d5f78 100644
--- a/pkgs/intl4x/lib/src/bindings/CaseMapper.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/CaseMapper.g.dart
@@ -213,20 +213,20 @@ final class CaseMapper implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XCaseMapper_destroy')
+@KeepSymbol('ICU4XCaseMapper_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XCaseMapper_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XCaseMapper_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XCaseMapper_create')
+@KeepSymbol('ICU4XCaseMapper_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCaseMapper_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCaseMapper_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCaseMapper_lowercase')
+@KeepSymbol('ICU4XCaseMapper_lowercase')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>,
@@ -243,7 +243,7 @@ external _ResultVoidInt32 _ICU4XCaseMapper_lowercase(
     ffi.Pointer<ffi.Opaque> locale,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XCaseMapper_uppercase')
+@KeepSymbol('ICU4XCaseMapper_uppercase')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>,
@@ -260,8 +260,7 @@ external _ResultVoidInt32 _ICU4XCaseMapper_uppercase(
     ffi.Pointer<ffi.Opaque> locale,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier(
-    'ICU4XCaseMapper_titlecase_segment_with_only_case_data_v1')
+@KeepSymbol('ICU4XCaseMapper_titlecase_segment_with_only_case_data_v1')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>,
@@ -282,7 +281,7 @@ external _ResultVoidInt32
         _TitlecaseOptionsFfi options,
         ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XCaseMapper_fold')
+@KeepSymbol('ICU4XCaseMapper_fold')
 @ffi.Native<
     _ResultVoidInt32 Function(
         ffi.Pointer<ffi.Opaque>,
@@ -296,7 +295,7 @@ external _ResultVoidInt32 _ICU4XCaseMapper_fold(
     int sLength,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XCaseMapper_fold_turkic')
+@KeepSymbol('ICU4XCaseMapper_fold_turkic')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Uint8>, ffi.Size, ffi.Pointer<ffi.Opaque>)>(
@@ -308,7 +307,7 @@ external _ResultVoidInt32 _ICU4XCaseMapper_fold_turkic(
     int sLength,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XCaseMapper_add_case_closure_to')
+@KeepSymbol('ICU4XCaseMapper_add_case_closure_to')
 @ffi.Native<
         ffi.Void Function(
             ffi.Pointer<ffi.Opaque>, ffi.Uint32, ffi.Pointer<ffi.Opaque>)>(
@@ -317,35 +316,35 @@ external _ResultVoidInt32 _ICU4XCaseMapper_fold_turkic(
 external void _ICU4XCaseMapper_add_case_closure_to(
     ffi.Pointer<ffi.Opaque> self, Rune c, ffi.Pointer<ffi.Opaque> builder);
 
-@meta.ResourceIdentifier('ICU4XCaseMapper_simple_lowercase')
+@KeepSymbol('ICU4XCaseMapper_simple_lowercase')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCaseMapper_simple_lowercase')
 // ignore: non_constant_identifier_names
 external Rune _ICU4XCaseMapper_simple_lowercase(
     ffi.Pointer<ffi.Opaque> self, Rune ch);
 
-@meta.ResourceIdentifier('ICU4XCaseMapper_simple_uppercase')
+@KeepSymbol('ICU4XCaseMapper_simple_uppercase')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCaseMapper_simple_uppercase')
 // ignore: non_constant_identifier_names
 external Rune _ICU4XCaseMapper_simple_uppercase(
     ffi.Pointer<ffi.Opaque> self, Rune ch);
 
-@meta.ResourceIdentifier('ICU4XCaseMapper_simple_titlecase')
+@KeepSymbol('ICU4XCaseMapper_simple_titlecase')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCaseMapper_simple_titlecase')
 // ignore: non_constant_identifier_names
 external Rune _ICU4XCaseMapper_simple_titlecase(
     ffi.Pointer<ffi.Opaque> self, Rune ch);
 
-@meta.ResourceIdentifier('ICU4XCaseMapper_simple_fold')
+@KeepSymbol('ICU4XCaseMapper_simple_fold')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCaseMapper_simple_fold')
 // ignore: non_constant_identifier_names
 external Rune _ICU4XCaseMapper_simple_fold(
     ffi.Pointer<ffi.Opaque> self, Rune ch);
 
-@meta.ResourceIdentifier('ICU4XCaseMapper_simple_fold_turkic')
+@KeepSymbol('ICU4XCaseMapper_simple_fold_turkic')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCaseMapper_simple_fold_turkic')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/CodePointMapData16.g.dart b/pkgs/intl4x/lib/src/bindings/CodePointMapData16.g.dart
index 9b736521..d132f848 100644
--- a/pkgs/intl4x/lib/src/bindings/CodePointMapData16.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/CodePointMapData16.g.dart
@@ -80,20 +80,20 @@ final class CodePointMapData16 implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData16_destroy')
+@KeepSymbol('ICU4XCodePointMapData16_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData16_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XCodePointMapData16_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData16_get')
+@KeepSymbol('ICU4XCodePointMapData16_get')
 @ffi.Native<ffi.Uint16 Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData16_get')
 // ignore: non_constant_identifier_names
 external int _ICU4XCodePointMapData16_get(
     ffi.Pointer<ffi.Opaque> self, Rune cp);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData16_iter_ranges_for_value')
+@KeepSymbol('ICU4XCodePointMapData16_iter_ranges_for_value')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>, ffi.Uint16)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData16_iter_ranges_for_value')
@@ -101,8 +101,7 @@ external int _ICU4XCodePointMapData16_get(
 external ffi.Pointer<ffi.Opaque> _ICU4XCodePointMapData16_iter_ranges_for_value(
     ffi.Pointer<ffi.Opaque> self, int value);
 
-@meta.ResourceIdentifier(
-    'ICU4XCodePointMapData16_iter_ranges_for_value_complemented')
+@KeepSymbol('ICU4XCodePointMapData16_iter_ranges_for_value_complemented')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>, ffi.Uint16)>(
     isLeaf: true,
@@ -112,7 +111,7 @@ external ffi.Pointer<ffi.Opaque>
     _ICU4XCodePointMapData16_iter_ranges_for_value_complemented(
         ffi.Pointer<ffi.Opaque> self, int value);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData16_get_set_for_value')
+@KeepSymbol('ICU4XCodePointMapData16_get_set_for_value')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>, ffi.Uint16)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData16_get_set_for_value')
@@ -120,7 +119,7 @@ external ffi.Pointer<ffi.Opaque>
 external ffi.Pointer<ffi.Opaque> _ICU4XCodePointMapData16_get_set_for_value(
     ffi.Pointer<ffi.Opaque> self, int value);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData16_load_script')
+@KeepSymbol('ICU4XCodePointMapData16_load_script')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData16_load_script')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/CodePointMapData8.g.dart b/pkgs/intl4x/lib/src/bindings/CodePointMapData8.g.dart
index d8250178..0b8346dc 100644
--- a/pkgs/intl4x/lib/src/bindings/CodePointMapData8.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/CodePointMapData8.g.dart
@@ -209,25 +209,25 @@ final class CodePointMapData8 implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData8_destroy')
+@KeepSymbol('ICU4XCodePointMapData8_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData8_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XCodePointMapData8_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData8_get')
+@KeepSymbol('ICU4XCodePointMapData8_get')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData8_get')
 // ignore: non_constant_identifier_names
 external int _ICU4XCodePointMapData8_get(ffi.Pointer<ffi.Opaque> self, Rune cp);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData8_general_category_to_mask')
+@KeepSymbol('ICU4XCodePointMapData8_general_category_to_mask')
 @ffi.Native<ffi.Uint32 Function(ffi.Uint8)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData8_general_category_to_mask')
 // ignore: non_constant_identifier_names
 external int _ICU4XCodePointMapData8_general_category_to_mask(int gc);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData8_iter_ranges_for_value')
+@KeepSymbol('ICU4XCodePointMapData8_iter_ranges_for_value')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>, ffi.Uint8)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData8_iter_ranges_for_value')
@@ -235,8 +235,7 @@ external int _ICU4XCodePointMapData8_general_category_to_mask(int gc);
 external ffi.Pointer<ffi.Opaque> _ICU4XCodePointMapData8_iter_ranges_for_value(
     ffi.Pointer<ffi.Opaque> self, int value);
 
-@meta.ResourceIdentifier(
-    'ICU4XCodePointMapData8_iter_ranges_for_value_complemented')
+@KeepSymbol('ICU4XCodePointMapData8_iter_ranges_for_value_complemented')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>, ffi.Uint8)>(
     isLeaf: true,
@@ -246,7 +245,7 @@ external ffi.Pointer<ffi.Opaque>
     _ICU4XCodePointMapData8_iter_ranges_for_value_complemented(
         ffi.Pointer<ffi.Opaque> self, int value);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData8_iter_ranges_for_mask')
+@KeepSymbol('ICU4XCodePointMapData8_iter_ranges_for_mask')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData8_iter_ranges_for_mask')
@@ -254,7 +253,7 @@ external ffi.Pointer<ffi.Opaque>
 external ffi.Pointer<ffi.Opaque> _ICU4XCodePointMapData8_iter_ranges_for_mask(
     ffi.Pointer<ffi.Opaque> self, int mask);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData8_get_set_for_value')
+@KeepSymbol('ICU4XCodePointMapData8_get_set_for_value')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>, ffi.Uint8)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData8_get_set_for_value')
@@ -262,35 +261,35 @@ external ffi.Pointer<ffi.Opaque> _ICU4XCodePointMapData8_iter_ranges_for_mask(
 external ffi.Pointer<ffi.Opaque> _ICU4XCodePointMapData8_get_set_for_value(
     ffi.Pointer<ffi.Opaque> self, int value);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData8_load_general_category')
+@KeepSymbol('ICU4XCodePointMapData8_load_general_category')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData8_load_general_category')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointMapData8_load_general_category(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData8_load_bidi_class')
+@KeepSymbol('ICU4XCodePointMapData8_load_bidi_class')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData8_load_bidi_class')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointMapData8_load_bidi_class(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData8_load_east_asian_width')
+@KeepSymbol('ICU4XCodePointMapData8_load_east_asian_width')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData8_load_east_asian_width')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointMapData8_load_east_asian_width(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData8_load_hangul_syllable_type')
+@KeepSymbol('ICU4XCodePointMapData8_load_hangul_syllable_type')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData8_load_hangul_syllable_type')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointMapData8_load_hangul_syllable_type(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData8_load_indic_syllabic_category')
+@KeepSymbol('ICU4XCodePointMapData8_load_indic_syllabic_category')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData8_load_indic_syllabic_category')
 // ignore: non_constant_identifier_names
@@ -298,35 +297,35 @@ external _ResultOpaqueInt32
     _ICU4XCodePointMapData8_load_indic_syllabic_category(
         ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData8_load_line_break')
+@KeepSymbol('ICU4XCodePointMapData8_load_line_break')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData8_load_line_break')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointMapData8_load_line_break(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData8_try_grapheme_cluster_break')
+@KeepSymbol('ICU4XCodePointMapData8_try_grapheme_cluster_break')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData8_try_grapheme_cluster_break')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointMapData8_try_grapheme_cluster_break(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData8_load_word_break')
+@KeepSymbol('ICU4XCodePointMapData8_load_word_break')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData8_load_word_break')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointMapData8_load_word_break(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData8_load_sentence_break')
+@KeepSymbol('ICU4XCodePointMapData8_load_sentence_break')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData8_load_sentence_break')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointMapData8_load_sentence_break(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointMapData8_load_joining_type')
+@KeepSymbol('ICU4XCodePointMapData8_load_joining_type')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointMapData8_load_joining_type')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/CodePointRangeIterator.g.dart b/pkgs/intl4x/lib/src/bindings/CodePointRangeIterator.g.dart
index 7cde79d4..d3e9cef1 100644
--- a/pkgs/intl4x/lib/src/bindings/CodePointRangeIterator.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/CodePointRangeIterator.g.dart
@@ -35,13 +35,13 @@ final class CodePointRangeIterator implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('CodePointRangeIterator_destroy')
+@KeepSymbol('CodePointRangeIterator_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'CodePointRangeIterator_destroy')
 // ignore: non_constant_identifier_names
 external void _CodePointRangeIterator_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('CodePointRangeIterator_next')
+@KeepSymbol('CodePointRangeIterator_next')
 @ffi.Native<_CodePointRangeIteratorResultFfi Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'CodePointRangeIterator_next')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/CodePointSetBuilder.g.dart b/pkgs/intl4x/lib/src/bindings/CodePointSetBuilder.g.dart
index 83963298..a9163bae 100644
--- a/pkgs/intl4x/lib/src/bindings/CodePointSetBuilder.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/CodePointSetBuilder.g.dart
@@ -149,53 +149,53 @@ final class CodePointSetBuilder implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_destroy')
+@KeepSymbol('ICU4XCodePointSetBuilder_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XCodePointSetBuilder_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_create')
+@KeepSymbol('ICU4XCodePointSetBuilder_create')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function()>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_create')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XCodePointSetBuilder_create();
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_build')
+@KeepSymbol('ICU4XCodePointSetBuilder_build')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_build')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XCodePointSetBuilder_build(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_complement')
+@KeepSymbol('ICU4XCodePointSetBuilder_complement')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_complement')
 // ignore: non_constant_identifier_names
 external void _ICU4XCodePointSetBuilder_complement(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_is_empty')
+@KeepSymbol('ICU4XCodePointSetBuilder_is_empty')
 @ffi.Native<ffi.Bool Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_is_empty')
 // ignore: non_constant_identifier_names
 external bool _ICU4XCodePointSetBuilder_is_empty(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_add_char')
+@KeepSymbol('ICU4XCodePointSetBuilder_add_char')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_add_char')
 // ignore: non_constant_identifier_names
 external void _ICU4XCodePointSetBuilder_add_char(
     ffi.Pointer<ffi.Opaque> self, Rune ch);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_add_inclusive_range')
+@KeepSymbol('ICU4XCodePointSetBuilder_add_inclusive_range')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_add_inclusive_range')
 // ignore: non_constant_identifier_names
 external void _ICU4XCodePointSetBuilder_add_inclusive_range(
     ffi.Pointer<ffi.Opaque> self, Rune start, Rune end);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_add_set')
+@KeepSymbol('ICU4XCodePointSetBuilder_add_set')
 @ffi.Native<
         ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_add_set')
@@ -203,21 +203,21 @@ external void _ICU4XCodePointSetBuilder_add_inclusive_range(
 external void _ICU4XCodePointSetBuilder_add_set(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> data);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_remove_char')
+@KeepSymbol('ICU4XCodePointSetBuilder_remove_char')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_remove_char')
 // ignore: non_constant_identifier_names
 external void _ICU4XCodePointSetBuilder_remove_char(
     ffi.Pointer<ffi.Opaque> self, Rune ch);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_remove_inclusive_range')
+@KeepSymbol('ICU4XCodePointSetBuilder_remove_inclusive_range')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_remove_inclusive_range')
 // ignore: non_constant_identifier_names
 external void _ICU4XCodePointSetBuilder_remove_inclusive_range(
     ffi.Pointer<ffi.Opaque> self, Rune start, Rune end);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_remove_set')
+@KeepSymbol('ICU4XCodePointSetBuilder_remove_set')
 @ffi.Native<
         ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_remove_set')
@@ -225,21 +225,21 @@ external void _ICU4XCodePointSetBuilder_remove_inclusive_range(
 external void _ICU4XCodePointSetBuilder_remove_set(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> data);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_retain_char')
+@KeepSymbol('ICU4XCodePointSetBuilder_retain_char')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_retain_char')
 // ignore: non_constant_identifier_names
 external void _ICU4XCodePointSetBuilder_retain_char(
     ffi.Pointer<ffi.Opaque> self, Rune ch);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_retain_inclusive_range')
+@KeepSymbol('ICU4XCodePointSetBuilder_retain_inclusive_range')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_retain_inclusive_range')
 // ignore: non_constant_identifier_names
 external void _ICU4XCodePointSetBuilder_retain_inclusive_range(
     ffi.Pointer<ffi.Opaque> self, Rune start, Rune end);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_retain_set')
+@KeepSymbol('ICU4XCodePointSetBuilder_retain_set')
 @ffi.Native<
         ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_retain_set')
@@ -247,21 +247,21 @@ external void _ICU4XCodePointSetBuilder_retain_inclusive_range(
 external void _ICU4XCodePointSetBuilder_retain_set(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> data);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_complement_char')
+@KeepSymbol('ICU4XCodePointSetBuilder_complement_char')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_complement_char')
 // ignore: non_constant_identifier_names
 external void _ICU4XCodePointSetBuilder_complement_char(
     ffi.Pointer<ffi.Opaque> self, Rune ch);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_complement_inclusive_range')
+@KeepSymbol('ICU4XCodePointSetBuilder_complement_inclusive_range')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_complement_inclusive_range')
 // ignore: non_constant_identifier_names
 external void _ICU4XCodePointSetBuilder_complement_inclusive_range(
     ffi.Pointer<ffi.Opaque> self, Rune start, Rune end);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetBuilder_complement_set')
+@KeepSymbol('ICU4XCodePointSetBuilder_complement_set')
 @ffi.Native<
         ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetBuilder_complement_set')
diff --git a/pkgs/intl4x/lib/src/bindings/CodePointSetData.g.dart b/pkgs/intl4x/lib/src/bindings/CodePointSetData.g.dart
index d114bfce..f90ae957 100644
--- a/pkgs/intl4x/lib/src/bindings/CodePointSetData.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/CodePointSetData.g.dart
@@ -832,27 +832,27 @@ final class CodePointSetData implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_destroy')
+@KeepSymbol('ICU4XCodePointSetData_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XCodePointSetData_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_contains')
+@KeepSymbol('ICU4XCodePointSetData_contains')
 @ffi.Native<ffi.Bool Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_contains')
 // ignore: non_constant_identifier_names
 external bool _ICU4XCodePointSetData_contains(
     ffi.Pointer<ffi.Opaque> self, Rune cp);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_iter_ranges')
+@KeepSymbol('ICU4XCodePointSetData_iter_ranges')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_iter_ranges')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XCodePointSetData_iter_ranges(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_iter_ranges_complemented')
+@KeepSymbol('ICU4XCodePointSetData_iter_ranges_complemented')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_iter_ranges_complemented')
 // ignore: non_constant_identifier_names
@@ -860,8 +860,7 @@ external ffi.Pointer<ffi.Opaque>
     _ICU4XCodePointSetData_iter_ranges_complemented(
         ffi.Pointer<ffi.Opaque> self);
 
-@meta
-    .ResourceIdentifier('ICU4XCodePointSetData_load_for_general_category_group')
+@KeepSymbol('ICU4XCodePointSetData_load_for_general_category_group')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true,
     symbol: 'ICU4XCodePointSetData_load_for_general_category_group')
@@ -870,64 +869,63 @@ external _ResultOpaqueInt32
     _ICU4XCodePointSetData_load_for_general_category_group(
         ffi.Pointer<ffi.Opaque> provider, int group);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_ascii_hex_digit')
+@KeepSymbol('ICU4XCodePointSetData_load_ascii_hex_digit')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_ascii_hex_digit')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_ascii_hex_digit(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_alnum')
+@KeepSymbol('ICU4XCodePointSetData_load_alnum')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_alnum')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_alnum(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_alphabetic')
+@KeepSymbol('ICU4XCodePointSetData_load_alphabetic')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_alphabetic')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_alphabetic(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_bidi_control')
+@KeepSymbol('ICU4XCodePointSetData_load_bidi_control')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_bidi_control')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_bidi_control(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_bidi_mirrored')
+@KeepSymbol('ICU4XCodePointSetData_load_bidi_mirrored')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_bidi_mirrored')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_bidi_mirrored(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_blank')
+@KeepSymbol('ICU4XCodePointSetData_load_blank')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_blank')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_blank(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_cased')
+@KeepSymbol('ICU4XCodePointSetData_load_cased')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_cased')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_cased(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_case_ignorable')
+@KeepSymbol('ICU4XCodePointSetData_load_case_ignorable')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_case_ignorable')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_case_ignorable(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta
-    .ResourceIdentifier('ICU4XCodePointSetData_load_full_composition_exclusion')
+@KeepSymbol('ICU4XCodePointSetData_load_full_composition_exclusion')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true,
     symbol: 'ICU4XCodePointSetData_load_full_composition_exclusion')
@@ -936,22 +934,21 @@ external _ResultOpaqueInt32
     _ICU4XCodePointSetData_load_full_composition_exclusion(
         ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_changes_when_casefolded')
+@KeepSymbol('ICU4XCodePointSetData_load_changes_when_casefolded')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_changes_when_casefolded')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_changes_when_casefolded(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_changes_when_casemapped')
+@KeepSymbol('ICU4XCodePointSetData_load_changes_when_casemapped')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_changes_when_casemapped')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_changes_when_casemapped(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier(
-    'ICU4XCodePointSetData_load_changes_when_nfkc_casefolded')
+@KeepSymbol('ICU4XCodePointSetData_load_changes_when_nfkc_casefolded')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true,
     symbol: 'ICU4XCodePointSetData_load_changes_when_nfkc_casefolded')
@@ -960,43 +957,42 @@ external _ResultOpaqueInt32
     _ICU4XCodePointSetData_load_changes_when_nfkc_casefolded(
         ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_changes_when_lowercased')
+@KeepSymbol('ICU4XCodePointSetData_load_changes_when_lowercased')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_changes_when_lowercased')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_changes_when_lowercased(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_changes_when_titlecased')
+@KeepSymbol('ICU4XCodePointSetData_load_changes_when_titlecased')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_changes_when_titlecased')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_changes_when_titlecased(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_changes_when_uppercased')
+@KeepSymbol('ICU4XCodePointSetData_load_changes_when_uppercased')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_changes_when_uppercased')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_changes_when_uppercased(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_dash')
+@KeepSymbol('ICU4XCodePointSetData_load_dash')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_dash')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_dash(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_deprecated')
+@KeepSymbol('ICU4XCodePointSetData_load_deprecated')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_deprecated')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_deprecated(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier(
-    'ICU4XCodePointSetData_load_default_ignorable_code_point')
+@KeepSymbol('ICU4XCodePointSetData_load_default_ignorable_code_point')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true,
     symbol: 'ICU4XCodePointSetData_load_default_ignorable_code_point')
@@ -1005,218 +1001,217 @@ external _ResultOpaqueInt32
     _ICU4XCodePointSetData_load_default_ignorable_code_point(
         ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_diacritic')
+@KeepSymbol('ICU4XCodePointSetData_load_diacritic')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_diacritic')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_diacritic(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_emoji_modifier_base')
+@KeepSymbol('ICU4XCodePointSetData_load_emoji_modifier_base')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_emoji_modifier_base')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_emoji_modifier_base(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_emoji_component')
+@KeepSymbol('ICU4XCodePointSetData_load_emoji_component')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_emoji_component')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_emoji_component(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_emoji_modifier')
+@KeepSymbol('ICU4XCodePointSetData_load_emoji_modifier')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_emoji_modifier')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_emoji_modifier(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_emoji')
+@KeepSymbol('ICU4XCodePointSetData_load_emoji')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_emoji')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_emoji(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_emoji_presentation')
+@KeepSymbol('ICU4XCodePointSetData_load_emoji_presentation')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_emoji_presentation')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_emoji_presentation(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_extender')
+@KeepSymbol('ICU4XCodePointSetData_load_extender')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_extender')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_extender(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_extended_pictographic')
+@KeepSymbol('ICU4XCodePointSetData_load_extended_pictographic')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_extended_pictographic')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_extended_pictographic(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_graph')
+@KeepSymbol('ICU4XCodePointSetData_load_graph')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_graph')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_graph(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_grapheme_base')
+@KeepSymbol('ICU4XCodePointSetData_load_grapheme_base')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_grapheme_base')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_grapheme_base(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_grapheme_extend')
+@KeepSymbol('ICU4XCodePointSetData_load_grapheme_extend')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_grapheme_extend')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_grapheme_extend(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_grapheme_link')
+@KeepSymbol('ICU4XCodePointSetData_load_grapheme_link')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_grapheme_link')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_grapheme_link(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_hex_digit')
+@KeepSymbol('ICU4XCodePointSetData_load_hex_digit')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_hex_digit')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_hex_digit(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_hyphen')
+@KeepSymbol('ICU4XCodePointSetData_load_hyphen')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_hyphen')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_hyphen(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_id_continue')
+@KeepSymbol('ICU4XCodePointSetData_load_id_continue')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_id_continue')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_id_continue(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_ideographic')
+@KeepSymbol('ICU4XCodePointSetData_load_ideographic')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_ideographic')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_ideographic(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_id_start')
+@KeepSymbol('ICU4XCodePointSetData_load_id_start')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_id_start')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_id_start(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_ids_binary_operator')
+@KeepSymbol('ICU4XCodePointSetData_load_ids_binary_operator')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_ids_binary_operator')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_ids_binary_operator(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_ids_trinary_operator')
+@KeepSymbol('ICU4XCodePointSetData_load_ids_trinary_operator')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_ids_trinary_operator')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_ids_trinary_operator(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_join_control')
+@KeepSymbol('ICU4XCodePointSetData_load_join_control')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_join_control')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_join_control(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_logical_order_exception')
+@KeepSymbol('ICU4XCodePointSetData_load_logical_order_exception')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_logical_order_exception')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_logical_order_exception(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_lowercase')
+@KeepSymbol('ICU4XCodePointSetData_load_lowercase')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_lowercase')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_lowercase(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_math')
+@KeepSymbol('ICU4XCodePointSetData_load_math')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_math')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_math(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_noncharacter_code_point')
+@KeepSymbol('ICU4XCodePointSetData_load_noncharacter_code_point')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_noncharacter_code_point')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_noncharacter_code_point(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_nfc_inert')
+@KeepSymbol('ICU4XCodePointSetData_load_nfc_inert')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_nfc_inert')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_nfc_inert(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_nfd_inert')
+@KeepSymbol('ICU4XCodePointSetData_load_nfd_inert')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_nfd_inert')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_nfd_inert(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_nfkc_inert')
+@KeepSymbol('ICU4XCodePointSetData_load_nfkc_inert')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_nfkc_inert')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_nfkc_inert(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_nfkd_inert')
+@KeepSymbol('ICU4XCodePointSetData_load_nfkd_inert')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_nfkd_inert')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_nfkd_inert(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_pattern_syntax')
+@KeepSymbol('ICU4XCodePointSetData_load_pattern_syntax')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_pattern_syntax')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_pattern_syntax(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_pattern_white_space')
+@KeepSymbol('ICU4XCodePointSetData_load_pattern_white_space')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_pattern_white_space')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_pattern_white_space(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier(
-    'ICU4XCodePointSetData_load_prepended_concatenation_mark')
+@KeepSymbol('ICU4XCodePointSetData_load_prepended_concatenation_mark')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true,
     symbol: 'ICU4XCodePointSetData_load_prepended_concatenation_mark')
@@ -1225,119 +1220,119 @@ external _ResultOpaqueInt32
     _ICU4XCodePointSetData_load_prepended_concatenation_mark(
         ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_print')
+@KeepSymbol('ICU4XCodePointSetData_load_print')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_print')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_print(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_quotation_mark')
+@KeepSymbol('ICU4XCodePointSetData_load_quotation_mark')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_quotation_mark')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_quotation_mark(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_radical')
+@KeepSymbol('ICU4XCodePointSetData_load_radical')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_radical')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_radical(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_regional_indicator')
+@KeepSymbol('ICU4XCodePointSetData_load_regional_indicator')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_regional_indicator')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_regional_indicator(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_soft_dotted')
+@KeepSymbol('ICU4XCodePointSetData_load_soft_dotted')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_soft_dotted')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_soft_dotted(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_segment_starter')
+@KeepSymbol('ICU4XCodePointSetData_load_segment_starter')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_segment_starter')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_segment_starter(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_case_sensitive')
+@KeepSymbol('ICU4XCodePointSetData_load_case_sensitive')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_case_sensitive')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_case_sensitive(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_sentence_terminal')
+@KeepSymbol('ICU4XCodePointSetData_load_sentence_terminal')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_sentence_terminal')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_sentence_terminal(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_terminal_punctuation')
+@KeepSymbol('ICU4XCodePointSetData_load_terminal_punctuation')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_terminal_punctuation')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_terminal_punctuation(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_unified_ideograph')
+@KeepSymbol('ICU4XCodePointSetData_load_unified_ideograph')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_unified_ideograph')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_unified_ideograph(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_uppercase')
+@KeepSymbol('ICU4XCodePointSetData_load_uppercase')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_uppercase')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_uppercase(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_variation_selector')
+@KeepSymbol('ICU4XCodePointSetData_load_variation_selector')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_variation_selector')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_variation_selector(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_white_space')
+@KeepSymbol('ICU4XCodePointSetData_load_white_space')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_white_space')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_white_space(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_xdigit')
+@KeepSymbol('ICU4XCodePointSetData_load_xdigit')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_xdigit')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_xdigit(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_xid_continue')
+@KeepSymbol('ICU4XCodePointSetData_load_xid_continue')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_xid_continue')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_xid_continue(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_xid_start')
+@KeepSymbol('ICU4XCodePointSetData_load_xid_start')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCodePointSetData_load_xid_start')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCodePointSetData_load_xid_start(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XCodePointSetData_load_for_ecma262')
+@KeepSymbol('ICU4XCodePointSetData_load_for_ecma262')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>, ffi.Size)>(
diff --git a/pkgs/intl4x/lib/src/bindings/Collator.g.dart b/pkgs/intl4x/lib/src/bindings/Collator.g.dart
index 48848a37..c6ca46c1 100644
--- a/pkgs/intl4x/lib/src/bindings/Collator.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/Collator.g.dart
@@ -67,13 +67,13 @@ final class Collator implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XCollator_destroy')
+@KeepSymbol('ICU4XCollator_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XCollator_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XCollator_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XCollator_create_v1')
+@KeepSymbol('ICU4XCollator_create_v1')
 @ffi.Native<
     _ResultOpaqueInt32 Function(
         ffi.Pointer<ffi.Opaque>,
@@ -85,7 +85,7 @@ external _ResultOpaqueInt32 _ICU4XCollator_create_v1(
     ffi.Pointer<ffi.Opaque> locale,
     _CollatorOptionsFfi options);
 
-@meta.ResourceIdentifier('ICU4XCollator_compare_utf16_')
+@KeepSymbol('ICU4XCollator_compare_utf16_')
 @ffi.Native<
     ffi.Int8 Function(
         ffi.Pointer<ffi.Opaque>,
@@ -101,7 +101,7 @@ external int _ICU4XCollator_compare_utf16_(
     ffi.Pointer<ffi.Uint16> rightData,
     int rightLength);
 
-@meta.ResourceIdentifier('ICU4XCollator_resolved_options')
+@KeepSymbol('ICU4XCollator_resolved_options')
 @ffi.Native<_ResolvedCollatorOptionsFfi Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCollator_resolved_options')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/ComposingNormalizer.g.dart b/pkgs/intl4x/lib/src/bindings/ComposingNormalizer.g.dart
index 648572e8..f6eaf877 100644
--- a/pkgs/intl4x/lib/src/bindings/ComposingNormalizer.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/ComposingNormalizer.g.dart
@@ -86,27 +86,27 @@ final class ComposingNormalizer implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XComposingNormalizer_destroy')
+@KeepSymbol('ICU4XComposingNormalizer_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XComposingNormalizer_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XComposingNormalizer_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XComposingNormalizer_create_nfc')
+@KeepSymbol('ICU4XComposingNormalizer_create_nfc')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XComposingNormalizer_create_nfc')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XComposingNormalizer_create_nfc(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XComposingNormalizer_create_nfkc')
+@KeepSymbol('ICU4XComposingNormalizer_create_nfkc')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XComposingNormalizer_create_nfkc')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XComposingNormalizer_create_nfkc(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XComposingNormalizer_normalize')
+@KeepSymbol('ICU4XComposingNormalizer_normalize')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Uint8>, ffi.Size, ffi.Pointer<ffi.Opaque>)>(
@@ -118,7 +118,7 @@ external _ResultVoidInt32 _ICU4XComposingNormalizer_normalize(
     int sLength,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XComposingNormalizer_is_normalized')
+@KeepSymbol('ICU4XComposingNormalizer_is_normalized')
 @ffi.Native<
         ffi.Bool Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>, ffi.Size)>(
diff --git a/pkgs/intl4x/lib/src/bindings/CustomTimeZone.g.dart b/pkgs/intl4x/lib/src/bindings/CustomTimeZone.g.dart
index ec6b3017..af868743 100644
--- a/pkgs/intl4x/lib/src/bindings/CustomTimeZone.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/CustomTimeZone.g.dart
@@ -402,81 +402,81 @@ final class CustomTimeZone implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_destroy')
+@KeepSymbol('ICU4XCustomTimeZone_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XCustomTimeZone_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_create_from_string')
+@KeepSymbol('ICU4XCustomTimeZone_create_from_string')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Uint8>, ffi.Size)>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_create_from_string')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XCustomTimeZone_create_from_string(
     ffi.Pointer<ffi.Uint8> sData, int sLength);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_create_empty')
+@KeepSymbol('ICU4XCustomTimeZone_create_empty')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function()>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_create_empty')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XCustomTimeZone_create_empty();
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_create_utc')
+@KeepSymbol('ICU4XCustomTimeZone_create_utc')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function()>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_create_utc')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XCustomTimeZone_create_utc();
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_try_set_gmt_offset_seconds')
+@KeepSymbol('ICU4XCustomTimeZone_try_set_gmt_offset_seconds')
 @ffi.Native<_ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_try_set_gmt_offset_seconds')
 // ignore: non_constant_identifier_names
 external _ResultVoidInt32 _ICU4XCustomTimeZone_try_set_gmt_offset_seconds(
     ffi.Pointer<ffi.Opaque> self, int offsetSeconds);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_clear_gmt_offset')
+@KeepSymbol('ICU4XCustomTimeZone_clear_gmt_offset')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_clear_gmt_offset')
 // ignore: non_constant_identifier_names
 external void _ICU4XCustomTimeZone_clear_gmt_offset(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_gmt_offset_seconds')
+@KeepSymbol('ICU4XCustomTimeZone_gmt_offset_seconds')
 @ffi.Native<_ResultInt32Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_gmt_offset_seconds')
 // ignore: non_constant_identifier_names
 external _ResultInt32Int32 _ICU4XCustomTimeZone_gmt_offset_seconds(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_is_gmt_offset_positive')
+@KeepSymbol('ICU4XCustomTimeZone_is_gmt_offset_positive')
 @ffi.Native<_ResultBoolInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_is_gmt_offset_positive')
 // ignore: non_constant_identifier_names
 external _ResultBoolInt32 _ICU4XCustomTimeZone_is_gmt_offset_positive(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_is_gmt_offset_zero')
+@KeepSymbol('ICU4XCustomTimeZone_is_gmt_offset_zero')
 @ffi.Native<_ResultBoolInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_is_gmt_offset_zero')
 // ignore: non_constant_identifier_names
 external _ResultBoolInt32 _ICU4XCustomTimeZone_is_gmt_offset_zero(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_gmt_offset_has_minutes')
+@KeepSymbol('ICU4XCustomTimeZone_gmt_offset_has_minutes')
 @ffi.Native<_ResultBoolInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_gmt_offset_has_minutes')
 // ignore: non_constant_identifier_names
 external _ResultBoolInt32 _ICU4XCustomTimeZone_gmt_offset_has_minutes(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_gmt_offset_has_seconds')
+@KeepSymbol('ICU4XCustomTimeZone_gmt_offset_has_seconds')
 @ffi.Native<_ResultBoolInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_gmt_offset_has_seconds')
 // ignore: non_constant_identifier_names
 external _ResultBoolInt32 _ICU4XCustomTimeZone_gmt_offset_has_seconds(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_try_set_time_zone_id')
+@KeepSymbol('ICU4XCustomTimeZone_try_set_time_zone_id')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>, ffi.Size)>(
@@ -485,7 +485,7 @@ external _ResultBoolInt32 _ICU4XCustomTimeZone_gmt_offset_has_seconds(
 external _ResultVoidInt32 _ICU4XCustomTimeZone_try_set_time_zone_id(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Uint8> idData, int idLength);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_try_set_iana_time_zone_id')
+@KeepSymbol('ICU4XCustomTimeZone_try_set_iana_time_zone_id')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>, ffi.Size)>(
@@ -497,7 +497,7 @@ external _ResultVoidInt32 _ICU4XCustomTimeZone_try_set_iana_time_zone_id(
     ffi.Pointer<ffi.Uint8> idData,
     int idLength);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_try_set_iana_time_zone_id_2')
+@KeepSymbol('ICU4XCustomTimeZone_try_set_iana_time_zone_id_2')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>, ffi.Size)>(
@@ -509,14 +509,14 @@ external _ResultVoidInt32 _ICU4XCustomTimeZone_try_set_iana_time_zone_id_2(
     ffi.Pointer<ffi.Uint8> idData,
     int idLength);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_clear_time_zone_id')
+@KeepSymbol('ICU4XCustomTimeZone_clear_time_zone_id')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_clear_time_zone_id')
 // ignore: non_constant_identifier_names
 external void _ICU4XCustomTimeZone_clear_time_zone_id(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_time_zone_id')
+@KeepSymbol('ICU4XCustomTimeZone_time_zone_id')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -525,7 +525,7 @@ external void _ICU4XCustomTimeZone_clear_time_zone_id(
 external _ResultVoidInt32 _ICU4XCustomTimeZone_time_zone_id(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_try_set_metazone_id')
+@KeepSymbol('ICU4XCustomTimeZone_try_set_metazone_id')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>, ffi.Size)>(
@@ -534,14 +534,14 @@ external _ResultVoidInt32 _ICU4XCustomTimeZone_time_zone_id(
 external _ResultVoidInt32 _ICU4XCustomTimeZone_try_set_metazone_id(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Uint8> idData, int idLength);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_clear_metazone_id')
+@KeepSymbol('ICU4XCustomTimeZone_clear_metazone_id')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_clear_metazone_id')
 // ignore: non_constant_identifier_names
 external void _ICU4XCustomTimeZone_clear_metazone_id(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_metazone_id')
+@KeepSymbol('ICU4XCustomTimeZone_metazone_id')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -550,7 +550,7 @@ external void _ICU4XCustomTimeZone_clear_metazone_id(
 external _ResultVoidInt32 _ICU4XCustomTimeZone_metazone_id(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_try_set_zone_variant')
+@KeepSymbol('ICU4XCustomTimeZone_try_set_zone_variant')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>, ffi.Size)>(
@@ -559,14 +559,14 @@ external _ResultVoidInt32 _ICU4XCustomTimeZone_metazone_id(
 external _ResultVoidInt32 _ICU4XCustomTimeZone_try_set_zone_variant(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Uint8> idData, int idLength);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_clear_zone_variant')
+@KeepSymbol('ICU4XCustomTimeZone_clear_zone_variant')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_clear_zone_variant')
 // ignore: non_constant_identifier_names
 external void _ICU4XCustomTimeZone_clear_zone_variant(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_zone_variant')
+@KeepSymbol('ICU4XCustomTimeZone_zone_variant')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -575,35 +575,35 @@ external void _ICU4XCustomTimeZone_clear_zone_variant(
 external _ResultVoidInt32 _ICU4XCustomTimeZone_zone_variant(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_set_standard_time')
+@KeepSymbol('ICU4XCustomTimeZone_set_standard_time')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_set_standard_time')
 // ignore: non_constant_identifier_names
 external void _ICU4XCustomTimeZone_set_standard_time(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_set_daylight_time')
+@KeepSymbol('ICU4XCustomTimeZone_set_daylight_time')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_set_daylight_time')
 // ignore: non_constant_identifier_names
 external void _ICU4XCustomTimeZone_set_daylight_time(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_is_standard_time')
+@KeepSymbol('ICU4XCustomTimeZone_is_standard_time')
 @ffi.Native<_ResultBoolInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_is_standard_time')
 // ignore: non_constant_identifier_names
 external _ResultBoolInt32 _ICU4XCustomTimeZone_is_standard_time(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_is_daylight_time')
+@KeepSymbol('ICU4XCustomTimeZone_is_daylight_time')
 @ffi.Native<_ResultBoolInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XCustomTimeZone_is_daylight_time')
 // ignore: non_constant_identifier_names
 external _ResultBoolInt32 _ICU4XCustomTimeZone_is_daylight_time(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XCustomTimeZone_maybe_calculate_metazone')
+@KeepSymbol('ICU4XCustomTimeZone_maybe_calculate_metazone')
 @ffi.Native<
         ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/DataProvider.g.dart b/pkgs/intl4x/lib/src/bindings/DataProvider.g.dart
index e9c7e067..aecb712d 100644
--- a/pkgs/intl4x/lib/src/bindings/DataProvider.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/DataProvider.g.dart
@@ -122,32 +122,32 @@ final class DataProvider implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XDataProvider_destroy')
+@KeepSymbol('ICU4XDataProvider_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XDataProvider_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XDataProvider_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XDataProvider_create_compiled')
+@KeepSymbol('ICU4XDataProvider_create_compiled')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function()>(
     isLeaf: true, symbol: 'ICU4XDataProvider_create_compiled')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XDataProvider_create_compiled();
 
-@meta.ResourceIdentifier('ICU4XDataProvider_create_from_byte_slice')
+@KeepSymbol('ICU4XDataProvider_create_from_byte_slice')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Uint8>, ffi.Size)>(
     isLeaf: true, symbol: 'ICU4XDataProvider_create_from_byte_slice')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XDataProvider_create_from_byte_slice(
     ffi.Pointer<ffi.Uint8> blobData, int blobLength);
 
-@meta.ResourceIdentifier('ICU4XDataProvider_create_empty')
+@KeepSymbol('ICU4XDataProvider_create_empty')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function()>(
     isLeaf: true, symbol: 'ICU4XDataProvider_create_empty')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XDataProvider_create_empty();
 
-@meta.ResourceIdentifier('ICU4XDataProvider_fork_by_key')
+@KeepSymbol('ICU4XDataProvider_fork_by_key')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -156,7 +156,7 @@ external ffi.Pointer<ffi.Opaque> _ICU4XDataProvider_create_empty();
 external _ResultVoidInt32 _ICU4XDataProvider_fork_by_key(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> other);
 
-@meta.ResourceIdentifier('ICU4XDataProvider_fork_by_locale')
+@KeepSymbol('ICU4XDataProvider_fork_by_locale')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -165,14 +165,14 @@ external _ResultVoidInt32 _ICU4XDataProvider_fork_by_key(
 external _ResultVoidInt32 _ICU4XDataProvider_fork_by_locale(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> other);
 
-@meta.ResourceIdentifier('ICU4XDataProvider_enable_locale_fallback')
+@KeepSymbol('ICU4XDataProvider_enable_locale_fallback')
 @ffi.Native<_ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDataProvider_enable_locale_fallback')
 // ignore: non_constant_identifier_names
 external _ResultVoidInt32 _ICU4XDataProvider_enable_locale_fallback(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDataProvider_enable_locale_fallback_with')
+@KeepSymbol('ICU4XDataProvider_enable_locale_fallback_with')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/Date.g.dart b/pkgs/intl4x/lib/src/bindings/Date.g.dart
index 94333d07..c5685fd3 100644
--- a/pkgs/intl4x/lib/src/bindings/Date.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/Date.g.dart
@@ -214,13 +214,13 @@ final class Date implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XDate_destroy')
+@KeepSymbol('ICU4XDate_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XDate_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XDate_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XDate_create_from_iso_in_calendar')
+@KeepSymbol('ICU4XDate_create_from_iso_in_calendar')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Int32, ffi.Uint8, ffi.Uint8, ffi.Pointer<ffi.Opaque>)>(
@@ -229,7 +229,7 @@ external void _ICU4XDate_destroy(ffi.Pointer<ffi.Void> self);
 external _ResultOpaqueInt32 _ICU4XDate_create_from_iso_in_calendar(
     int year, int month, int day, ffi.Pointer<ffi.Opaque> calendar);
 
-@meta.ResourceIdentifier('ICU4XDate_create_from_codes_in_calendar')
+@KeepSymbol('ICU4XDate_create_from_codes_in_calendar')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Uint8>,
@@ -250,7 +250,7 @@ external _ResultOpaqueInt32 _ICU4XDate_create_from_codes_in_calendar(
     int day,
     ffi.Pointer<ffi.Opaque> calendar);
 
-@meta.ResourceIdentifier('ICU4XDate_to_calendar')
+@KeepSymbol('ICU4XDate_to_calendar')
 @ffi.Native<
     ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>,
         ffi.Pointer<ffi.Opaque>)>(isLeaf: true, symbol: 'ICU4XDate_to_calendar')
@@ -258,39 +258,39 @@ external _ResultOpaqueInt32 _ICU4XDate_create_from_codes_in_calendar(
 external ffi.Pointer<ffi.Opaque> _ICU4XDate_to_calendar(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> calendar);
 
-@meta.ResourceIdentifier('ICU4XDate_to_iso')
+@KeepSymbol('ICU4XDate_to_iso')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDate_to_iso')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XDate_to_iso(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDate_day_of_year')
+@KeepSymbol('ICU4XDate_day_of_year')
 @ffi.Native<ffi.Uint16 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDate_day_of_year')
 // ignore: non_constant_identifier_names
 external int _ICU4XDate_day_of_year(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDate_day_of_month')
+@KeepSymbol('ICU4XDate_day_of_month')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDate_day_of_month')
 // ignore: non_constant_identifier_names
 external int _ICU4XDate_day_of_month(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDate_day_of_week')
+@KeepSymbol('ICU4XDate_day_of_week')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDate_day_of_week')
 // ignore: non_constant_identifier_names
 external int _ICU4XDate_day_of_week(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDate_week_of_month')
+@KeepSymbol('ICU4XDate_week_of_month')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XDate_week_of_month')
 // ignore: non_constant_identifier_names
 external int _ICU4XDate_week_of_month(
     ffi.Pointer<ffi.Opaque> self, int firstWeekday);
 
-@meta.ResourceIdentifier('ICU4XDate_week_of_year')
+@KeepSymbol('ICU4XDate_week_of_year')
 @ffi.Native<
         _ResultWeekOfFfiInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -299,13 +299,13 @@ external int _ICU4XDate_week_of_month(
 external _ResultWeekOfFfiInt32 _ICU4XDate_week_of_year(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> calculator);
 
-@meta.ResourceIdentifier('ICU4XDate_ordinal_month')
+@KeepSymbol('ICU4XDate_ordinal_month')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDate_ordinal_month')
 // ignore: non_constant_identifier_names
 external int _ICU4XDate_ordinal_month(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDate_month_code')
+@KeepSymbol('ICU4XDate_month_code')
 @ffi.Native<
     _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
         ffi.Pointer<ffi.Opaque>)>(isLeaf: true, symbol: 'ICU4XDate_month_code')
@@ -313,13 +313,13 @@ external int _ICU4XDate_ordinal_month(ffi.Pointer<ffi.Opaque> self);
 external _ResultVoidInt32 _ICU4XDate_month_code(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XDate_year_in_era')
+@KeepSymbol('ICU4XDate_year_in_era')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDate_year_in_era')
 // ignore: non_constant_identifier_names
 external int _ICU4XDate_year_in_era(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDate_era')
+@KeepSymbol('ICU4XDate_era')
 @ffi.Native<
     _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
         ffi.Pointer<ffi.Opaque>)>(isLeaf: true, symbol: 'ICU4XDate_era')
@@ -327,25 +327,25 @@ external int _ICU4XDate_year_in_era(ffi.Pointer<ffi.Opaque> self);
 external _ResultVoidInt32 _ICU4XDate_era(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XDate_months_in_year')
+@KeepSymbol('ICU4XDate_months_in_year')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDate_months_in_year')
 // ignore: non_constant_identifier_names
 external int _ICU4XDate_months_in_year(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDate_days_in_month')
+@KeepSymbol('ICU4XDate_days_in_month')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDate_days_in_month')
 // ignore: non_constant_identifier_names
 external int _ICU4XDate_days_in_month(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDate_days_in_year')
+@KeepSymbol('ICU4XDate_days_in_year')
 @ffi.Native<ffi.Uint16 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDate_days_in_year')
 // ignore: non_constant_identifier_names
 external int _ICU4XDate_days_in_year(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDate_calendar')
+@KeepSymbol('ICU4XDate_calendar')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDate_calendar')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/DateFormatter.g.dart b/pkgs/intl4x/lib/src/bindings/DateFormatter.g.dart
index 0dd7c6ab..a5f38dde 100644
--- a/pkgs/intl4x/lib/src/bindings/DateFormatter.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/DateFormatter.g.dart
@@ -106,13 +106,13 @@ final class DateFormatter implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XDateFormatter_destroy')
+@KeepSymbol('ICU4XDateFormatter_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XDateFormatter_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XDateFormatter_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XDateFormatter_create_with_length')
+@KeepSymbol('ICU4XDateFormatter_create_with_length')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>, ffi.Int32)>(
@@ -123,7 +123,7 @@ external _ResultOpaqueInt32 _ICU4XDateFormatter_create_with_length(
     ffi.Pointer<ffi.Opaque> locale,
     int dateLength);
 
-@meta.ResourceIdentifier('ICU4XDateFormatter_format_date')
+@KeepSymbol('ICU4XDateFormatter_format_date')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -134,7 +134,7 @@ external _ResultVoidInt32 _ICU4XDateFormatter_format_date(
     ffi.Pointer<ffi.Opaque> value,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XDateFormatter_format_iso_date')
+@KeepSymbol('ICU4XDateFormatter_format_iso_date')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -145,7 +145,7 @@ external _ResultVoidInt32 _ICU4XDateFormatter_format_iso_date(
     ffi.Pointer<ffi.Opaque> value,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XDateFormatter_format_datetime')
+@KeepSymbol('ICU4XDateFormatter_format_datetime')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -156,7 +156,7 @@ external _ResultVoidInt32 _ICU4XDateFormatter_format_datetime(
     ffi.Pointer<ffi.Opaque> value,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XDateFormatter_format_iso_datetime')
+@KeepSymbol('ICU4XDateFormatter_format_iso_datetime')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/DateTime.g.dart b/pkgs/intl4x/lib/src/bindings/DateTime.g.dart
index 345a7717..351e5667 100644
--- a/pkgs/intl4x/lib/src/bindings/DateTime.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/DateTime.g.dart
@@ -281,13 +281,13 @@ final class DateTime implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XDateTime_destroy')
+@KeepSymbol('ICU4XDateTime_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XDateTime_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XDateTime_create_from_iso_in_calendar')
+@KeepSymbol('ICU4XDateTime_create_from_iso_in_calendar')
 @ffi.Native<
         _ResultOpaqueInt32 Function(ffi.Int32, ffi.Uint8, ffi.Uint8, ffi.Uint8,
             ffi.Uint8, ffi.Uint8, ffi.Uint32, ffi.Pointer<ffi.Opaque>)>(
@@ -303,7 +303,7 @@ external _ResultOpaqueInt32 _ICU4XDateTime_create_from_iso_in_calendar(
     int nanosecond,
     ffi.Pointer<ffi.Opaque> calendar);
 
-@meta.ResourceIdentifier('ICU4XDateTime_create_from_codes_in_calendar')
+@KeepSymbol('ICU4XDateTime_create_from_codes_in_calendar')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Uint8>,
@@ -332,7 +332,7 @@ external _ResultOpaqueInt32 _ICU4XDateTime_create_from_codes_in_calendar(
     int nanosecond,
     ffi.Pointer<ffi.Opaque> calendar);
 
-@meta.ResourceIdentifier('ICU4XDateTime_create_from_date_and_time')
+@KeepSymbol('ICU4XDateTime_create_from_date_and_time')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -341,28 +341,28 @@ external _ResultOpaqueInt32 _ICU4XDateTime_create_from_codes_in_calendar(
 external ffi.Pointer<ffi.Opaque> _ICU4XDateTime_create_from_date_and_time(
     ffi.Pointer<ffi.Opaque> date, ffi.Pointer<ffi.Opaque> time);
 
-@meta.ResourceIdentifier('ICU4XDateTime_date')
+@KeepSymbol('ICU4XDateTime_date')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_date')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XDateTime_date(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDateTime_time')
+@KeepSymbol('ICU4XDateTime_time')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_time')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XDateTime_time(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDateTime_to_iso')
+@KeepSymbol('ICU4XDateTime_to_iso')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_to_iso')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XDateTime_to_iso(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDateTime_to_calendar')
+@KeepSymbol('ICU4XDateTime_to_calendar')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -371,56 +371,56 @@ external ffi.Pointer<ffi.Opaque> _ICU4XDateTime_to_iso(
 external ffi.Pointer<ffi.Opaque> _ICU4XDateTime_to_calendar(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> calendar);
 
-@meta.ResourceIdentifier('ICU4XDateTime_hour')
+@KeepSymbol('ICU4XDateTime_hour')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_hour')
 // ignore: non_constant_identifier_names
 external int _ICU4XDateTime_hour(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDateTime_minute')
+@KeepSymbol('ICU4XDateTime_minute')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_minute')
 // ignore: non_constant_identifier_names
 external int _ICU4XDateTime_minute(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDateTime_second')
+@KeepSymbol('ICU4XDateTime_second')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_second')
 // ignore: non_constant_identifier_names
 external int _ICU4XDateTime_second(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDateTime_nanosecond')
+@KeepSymbol('ICU4XDateTime_nanosecond')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_nanosecond')
 // ignore: non_constant_identifier_names
 external int _ICU4XDateTime_nanosecond(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDateTime_day_of_year')
+@KeepSymbol('ICU4XDateTime_day_of_year')
 @ffi.Native<ffi.Uint16 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_day_of_year')
 // ignore: non_constant_identifier_names
 external int _ICU4XDateTime_day_of_year(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDateTime_day_of_month')
+@KeepSymbol('ICU4XDateTime_day_of_month')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_day_of_month')
 // ignore: non_constant_identifier_names
 external int _ICU4XDateTime_day_of_month(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDateTime_day_of_week')
+@KeepSymbol('ICU4XDateTime_day_of_week')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_day_of_week')
 // ignore: non_constant_identifier_names
 external int _ICU4XDateTime_day_of_week(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDateTime_week_of_month')
+@KeepSymbol('ICU4XDateTime_week_of_month')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XDateTime_week_of_month')
 // ignore: non_constant_identifier_names
 external int _ICU4XDateTime_week_of_month(
     ffi.Pointer<ffi.Opaque> self, int firstWeekday);
 
-@meta.ResourceIdentifier('ICU4XDateTime_week_of_year')
+@KeepSymbol('ICU4XDateTime_week_of_year')
 @ffi.Native<
         _ResultWeekOfFfiInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -429,13 +429,13 @@ external int _ICU4XDateTime_week_of_month(
 external _ResultWeekOfFfiInt32 _ICU4XDateTime_week_of_year(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> calculator);
 
-@meta.ResourceIdentifier('ICU4XDateTime_ordinal_month')
+@KeepSymbol('ICU4XDateTime_ordinal_month')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_ordinal_month')
 // ignore: non_constant_identifier_names
 external int _ICU4XDateTime_ordinal_month(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDateTime_month_code')
+@KeepSymbol('ICU4XDateTime_month_code')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -444,13 +444,13 @@ external int _ICU4XDateTime_ordinal_month(ffi.Pointer<ffi.Opaque> self);
 external _ResultVoidInt32 _ICU4XDateTime_month_code(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XDateTime_year_in_era')
+@KeepSymbol('ICU4XDateTime_year_in_era')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_year_in_era')
 // ignore: non_constant_identifier_names
 external int _ICU4XDateTime_year_in_era(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDateTime_era')
+@KeepSymbol('ICU4XDateTime_era')
 @ffi.Native<
     _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
         ffi.Pointer<ffi.Opaque>)>(isLeaf: true, symbol: 'ICU4XDateTime_era')
@@ -458,25 +458,25 @@ external int _ICU4XDateTime_year_in_era(ffi.Pointer<ffi.Opaque> self);
 external _ResultVoidInt32 _ICU4XDateTime_era(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XDateTime_months_in_year')
+@KeepSymbol('ICU4XDateTime_months_in_year')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_months_in_year')
 // ignore: non_constant_identifier_names
 external int _ICU4XDateTime_months_in_year(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDateTime_days_in_month')
+@KeepSymbol('ICU4XDateTime_days_in_month')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_days_in_month')
 // ignore: non_constant_identifier_names
 external int _ICU4XDateTime_days_in_month(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDateTime_days_in_year')
+@KeepSymbol('ICU4XDateTime_days_in_year')
 @ffi.Native<ffi.Uint16 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_days_in_year')
 // ignore: non_constant_identifier_names
 external int _ICU4XDateTime_days_in_year(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XDateTime_calendar')
+@KeepSymbol('ICU4XDateTime_calendar')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDateTime_calendar')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/DateTimeFormatter.g.dart b/pkgs/intl4x/lib/src/bindings/DateTimeFormatter.g.dart
index 7a61da31..471304d0 100644
--- a/pkgs/intl4x/lib/src/bindings/DateTimeFormatter.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/DateTimeFormatter.g.dart
@@ -74,13 +74,13 @@ final class DateTimeFormatter implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XDateTimeFormatter_destroy')
+@KeepSymbol('ICU4XDateTimeFormatter_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XDateTimeFormatter_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XDateTimeFormatter_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XDateTimeFormatter_create_with_lengths')
+@KeepSymbol('ICU4XDateTimeFormatter_create_with_lengths')
 @ffi.Native<
         _ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Int32, ffi.Int32)>(
@@ -92,7 +92,7 @@ external _ResultOpaqueInt32 _ICU4XDateTimeFormatter_create_with_lengths(
     int dateLength,
     int timeLength);
 
-@meta.ResourceIdentifier('ICU4XDateTimeFormatter_format_datetime')
+@KeepSymbol('ICU4XDateTimeFormatter_format_datetime')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -103,7 +103,7 @@ external _ResultVoidInt32 _ICU4XDateTimeFormatter_format_datetime(
     ffi.Pointer<ffi.Opaque> value,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XDateTimeFormatter_format_iso_datetime')
+@KeepSymbol('ICU4XDateTimeFormatter_format_iso_datetime')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/DecomposingNormalizer.g.dart b/pkgs/intl4x/lib/src/bindings/DecomposingNormalizer.g.dart
index cced0ed0..3363b3b4 100644
--- a/pkgs/intl4x/lib/src/bindings/DecomposingNormalizer.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/DecomposingNormalizer.g.dart
@@ -86,27 +86,27 @@ final class DecomposingNormalizer implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XDecomposingNormalizer_destroy')
+@KeepSymbol('ICU4XDecomposingNormalizer_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XDecomposingNormalizer_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XDecomposingNormalizer_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XDecomposingNormalizer_create_nfd')
+@KeepSymbol('ICU4XDecomposingNormalizer_create_nfd')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDecomposingNormalizer_create_nfd')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XDecomposingNormalizer_create_nfd(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XDecomposingNormalizer_create_nfkd')
+@KeepSymbol('ICU4XDecomposingNormalizer_create_nfkd')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XDecomposingNormalizer_create_nfkd')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XDecomposingNormalizer_create_nfkd(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XDecomposingNormalizer_normalize')
+@KeepSymbol('ICU4XDecomposingNormalizer_normalize')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Uint8>, ffi.Size, ffi.Pointer<ffi.Opaque>)>(
@@ -118,7 +118,7 @@ external _ResultVoidInt32 _ICU4XDecomposingNormalizer_normalize(
     int sLength,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XDecomposingNormalizer_is_normalized')
+@KeepSymbol('ICU4XDecomposingNormalizer_is_normalized')
 @ffi.Native<
         ffi.Bool Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>, ffi.Size)>(
diff --git a/pkgs/intl4x/lib/src/bindings/FixedDecimal.g.dart b/pkgs/intl4x/lib/src/bindings/FixedDecimal.g.dart
index f5243d9a..f36ce733 100644
--- a/pkgs/intl4x/lib/src/bindings/FixedDecimal.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/FixedDecimal.g.dart
@@ -304,20 +304,19 @@ final class FixedDecimal implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_destroy')
+@KeepSymbol('ICU4XFixedDecimal_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_create_from_i64')
+@KeepSymbol('ICU4XFixedDecimal_create_from_i64')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Int64)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_create_from_i64')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XFixedDecimal_create_from_i64(int v);
 
-@meta.ResourceIdentifier(
-    'ICU4XFixedDecimal_create_from_f64_with_lower_magnitude')
+@KeepSymbol('ICU4XFixedDecimal_create_from_f64_with_lower_magnitude')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Double, ffi.Int16)>(
     isLeaf: true,
     symbol: 'ICU4XFixedDecimal_create_from_f64_with_lower_magnitude')
@@ -326,8 +325,7 @@ external _ResultOpaqueInt32
     _ICU4XFixedDecimal_create_from_f64_with_lower_magnitude(
         double f, int magnitude);
 
-@meta.ResourceIdentifier(
-    'ICU4XFixedDecimal_create_from_f64_with_significant_digits')
+@KeepSymbol('ICU4XFixedDecimal_create_from_f64_with_significant_digits')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Double, ffi.Uint8)>(
     isLeaf: true,
     symbol: 'ICU4XFixedDecimal_create_from_f64_with_significant_digits')
@@ -336,8 +334,7 @@ external _ResultOpaqueInt32
     _ICU4XFixedDecimal_create_from_f64_with_significant_digits(
         double f, int digits);
 
-@meta.ResourceIdentifier(
-    'ICU4XFixedDecimal_create_from_f64_with_floating_precision')
+@KeepSymbol('ICU4XFixedDecimal_create_from_f64_with_floating_precision')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Double)>(
     isLeaf: true,
     symbol: 'ICU4XFixedDecimal_create_from_f64_with_floating_precision')
@@ -345,239 +342,239 @@ external _ResultOpaqueInt32
 external _ResultOpaqueInt32
     _ICU4XFixedDecimal_create_from_f64_with_floating_precision(double f);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_create_from_string')
+@KeepSymbol('ICU4XFixedDecimal_create_from_string')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Uint8>, ffi.Size)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_create_from_string')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XFixedDecimal_create_from_string(
     ffi.Pointer<ffi.Uint8> vData, int vLength);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_digit_at')
+@KeepSymbol('ICU4XFixedDecimal_digit_at')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>, ffi.Int16)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_digit_at')
 // ignore: non_constant_identifier_names
 external int _ICU4XFixedDecimal_digit_at(
     ffi.Pointer<ffi.Opaque> self, int magnitude);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_magnitude_start')
+@KeepSymbol('ICU4XFixedDecimal_magnitude_start')
 @ffi.Native<ffi.Int16 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_magnitude_start')
 // ignore: non_constant_identifier_names
 external int _ICU4XFixedDecimal_magnitude_start(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_magnitude_end')
+@KeepSymbol('ICU4XFixedDecimal_magnitude_end')
 @ffi.Native<ffi.Int16 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_magnitude_end')
 // ignore: non_constant_identifier_names
 external int _ICU4XFixedDecimal_magnitude_end(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_nonzero_magnitude_start')
+@KeepSymbol('ICU4XFixedDecimal_nonzero_magnitude_start')
 @ffi.Native<ffi.Int16 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_nonzero_magnitude_start')
 // ignore: non_constant_identifier_names
 external int _ICU4XFixedDecimal_nonzero_magnitude_start(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_nonzero_magnitude_end')
+@KeepSymbol('ICU4XFixedDecimal_nonzero_magnitude_end')
 @ffi.Native<ffi.Int16 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_nonzero_magnitude_end')
 // ignore: non_constant_identifier_names
 external int _ICU4XFixedDecimal_nonzero_magnitude_end(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_is_zero')
+@KeepSymbol('ICU4XFixedDecimal_is_zero')
 @ffi.Native<ffi.Bool Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_is_zero')
 // ignore: non_constant_identifier_names
 external bool _ICU4XFixedDecimal_is_zero(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_multiply_pow10')
+@KeepSymbol('ICU4XFixedDecimal_multiply_pow10')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_multiply_pow10')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_multiply_pow10(
     ffi.Pointer<ffi.Opaque> self, int power);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_sign')
+@KeepSymbol('ICU4XFixedDecimal_sign')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_sign')
 // ignore: non_constant_identifier_names
 external int _ICU4XFixedDecimal_sign(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_set_sign')
+@KeepSymbol('ICU4XFixedDecimal_set_sign')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_set_sign')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_set_sign(
     ffi.Pointer<ffi.Opaque> self, int sign);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_apply_sign_display')
+@KeepSymbol('ICU4XFixedDecimal_apply_sign_display')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_apply_sign_display')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_apply_sign_display(
     ffi.Pointer<ffi.Opaque> self, int signDisplay);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_trim_start')
+@KeepSymbol('ICU4XFixedDecimal_trim_start')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_trim_start')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_trim_start(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_trim_end')
+@KeepSymbol('ICU4XFixedDecimal_trim_end')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_trim_end')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_trim_end(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_pad_start')
+@KeepSymbol('ICU4XFixedDecimal_pad_start')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_pad_start')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_pad_start(
     ffi.Pointer<ffi.Opaque> self, int position);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_pad_end')
+@KeepSymbol('ICU4XFixedDecimal_pad_end')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_pad_end')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_pad_end(
     ffi.Pointer<ffi.Opaque> self, int position);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_set_max_position')
+@KeepSymbol('ICU4XFixedDecimal_set_max_position')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_set_max_position')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_set_max_position(
     ffi.Pointer<ffi.Opaque> self, int position);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_trunc')
+@KeepSymbol('ICU4XFixedDecimal_trunc')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_trunc')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_trunc(
     ffi.Pointer<ffi.Opaque> self, int position);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_trunc_to_increment')
+@KeepSymbol('ICU4XFixedDecimal_trunc_to_increment')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_trunc_to_increment')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_trunc_to_increment(
     ffi.Pointer<ffi.Opaque> self, int position, int increment);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_half_trunc')
+@KeepSymbol('ICU4XFixedDecimal_half_trunc')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_half_trunc')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_half_trunc(
     ffi.Pointer<ffi.Opaque> self, int position);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_half_trunc_to_increment')
+@KeepSymbol('ICU4XFixedDecimal_half_trunc_to_increment')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_half_trunc_to_increment')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_half_trunc_to_increment(
     ffi.Pointer<ffi.Opaque> self, int position, int increment);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_expand')
+@KeepSymbol('ICU4XFixedDecimal_expand')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_expand')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_expand(
     ffi.Pointer<ffi.Opaque> self, int position);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_expand_to_increment')
+@KeepSymbol('ICU4XFixedDecimal_expand_to_increment')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_expand_to_increment')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_expand_to_increment(
     ffi.Pointer<ffi.Opaque> self, int position, int increment);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_half_expand')
+@KeepSymbol('ICU4XFixedDecimal_half_expand')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_half_expand')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_half_expand(
     ffi.Pointer<ffi.Opaque> self, int position);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_half_expand_to_increment')
+@KeepSymbol('ICU4XFixedDecimal_half_expand_to_increment')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_half_expand_to_increment')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_half_expand_to_increment(
     ffi.Pointer<ffi.Opaque> self, int position, int increment);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_ceil')
+@KeepSymbol('ICU4XFixedDecimal_ceil')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_ceil')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_ceil(
     ffi.Pointer<ffi.Opaque> self, int position);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_ceil_to_increment')
+@KeepSymbol('ICU4XFixedDecimal_ceil_to_increment')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_ceil_to_increment')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_ceil_to_increment(
     ffi.Pointer<ffi.Opaque> self, int position, int increment);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_half_ceil')
+@KeepSymbol('ICU4XFixedDecimal_half_ceil')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_half_ceil')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_half_ceil(
     ffi.Pointer<ffi.Opaque> self, int position);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_half_ceil_to_increment')
+@KeepSymbol('ICU4XFixedDecimal_half_ceil_to_increment')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_half_ceil_to_increment')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_half_ceil_to_increment(
     ffi.Pointer<ffi.Opaque> self, int position, int increment);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_floor')
+@KeepSymbol('ICU4XFixedDecimal_floor')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_floor')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_floor(
     ffi.Pointer<ffi.Opaque> self, int position);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_floor_to_increment')
+@KeepSymbol('ICU4XFixedDecimal_floor_to_increment')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_floor_to_increment')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_floor_to_increment(
     ffi.Pointer<ffi.Opaque> self, int position, int increment);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_half_floor')
+@KeepSymbol('ICU4XFixedDecimal_half_floor')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_half_floor')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_half_floor(
     ffi.Pointer<ffi.Opaque> self, int position);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_half_floor_to_increment')
+@KeepSymbol('ICU4XFixedDecimal_half_floor_to_increment')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_half_floor_to_increment')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_half_floor_to_increment(
     ffi.Pointer<ffi.Opaque> self, int position, int increment);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_half_even')
+@KeepSymbol('ICU4XFixedDecimal_half_even')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_half_even')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_half_even(
     ffi.Pointer<ffi.Opaque> self, int position);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_half_even_to_increment')
+@KeepSymbol('ICU4XFixedDecimal_half_even_to_increment')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Int16, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_half_even_to_increment')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimal_half_even_to_increment(
     ffi.Pointer<ffi.Opaque> self, int position, int increment);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_concatenate_end')
+@KeepSymbol('ICU4XFixedDecimal_concatenate_end')
 @ffi.Native<
         _ResultVoidVoid Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -586,7 +583,7 @@ external void _ICU4XFixedDecimal_half_even_to_increment(
 external _ResultVoidVoid _ICU4XFixedDecimal_concatenate_end(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> other);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimal_to_string')
+@KeepSymbol('ICU4XFixedDecimal_to_string')
 @ffi.Native<
         ffi.Void Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimal_to_string')
diff --git a/pkgs/intl4x/lib/src/bindings/FixedDecimalFormatter.g.dart b/pkgs/intl4x/lib/src/bindings/FixedDecimalFormatter.g.dart
index 5a9313f0..99a30b77 100644
--- a/pkgs/intl4x/lib/src/bindings/FixedDecimalFormatter.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/FixedDecimalFormatter.g.dart
@@ -56,14 +56,13 @@ final class FixedDecimalFormatter implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XFixedDecimalFormatter_destroy')
+@KeepSymbol('ICU4XFixedDecimalFormatter_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XFixedDecimalFormatter_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XFixedDecimalFormatter_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier(
-    'ICU4XFixedDecimalFormatter_create_with_grouping_strategy')
+@KeepSymbol('ICU4XFixedDecimalFormatter_create_with_grouping_strategy')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>, ffi.Int32)>(
@@ -76,7 +75,7 @@ external _ResultOpaqueInt32
         ffi.Pointer<ffi.Opaque> locale,
         int groupingStrategy);
 
-@meta.ResourceIdentifier('ICU4XFixedDecimalFormatter_format')
+@KeepSymbol('ICU4XFixedDecimalFormatter_format')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/GeneralCategoryNameToMaskMapper.g.dart b/pkgs/intl4x/lib/src/bindings/GeneralCategoryNameToMaskMapper.g.dart
index fa366554..b8c793d6 100644
--- a/pkgs/intl4x/lib/src/bindings/GeneralCategoryNameToMaskMapper.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/GeneralCategoryNameToMaskMapper.g.dart
@@ -63,14 +63,14 @@ final class GeneralCategoryNameToMaskMapper implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XGeneralCategoryNameToMaskMapper_destroy')
+@KeepSymbol('ICU4XGeneralCategoryNameToMaskMapper_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XGeneralCategoryNameToMaskMapper_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XGeneralCategoryNameToMaskMapper_destroy(
     ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XGeneralCategoryNameToMaskMapper_get_strict')
+@KeepSymbol('ICU4XGeneralCategoryNameToMaskMapper_get_strict')
 @ffi.Native<
         ffi.Uint32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>, ffi.Size)>(
@@ -81,7 +81,7 @@ external int _ICU4XGeneralCategoryNameToMaskMapper_get_strict(
     ffi.Pointer<ffi.Uint8> nameData,
     int nameLength);
 
-@meta.ResourceIdentifier('ICU4XGeneralCategoryNameToMaskMapper_get_loose')
+@KeepSymbol('ICU4XGeneralCategoryNameToMaskMapper_get_loose')
 @ffi.Native<
         ffi.Uint32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>, ffi.Size)>(
@@ -92,7 +92,7 @@ external int _ICU4XGeneralCategoryNameToMaskMapper_get_loose(
     ffi.Pointer<ffi.Uint8> nameData,
     int nameLength);
 
-@meta.ResourceIdentifier('ICU4XGeneralCategoryNameToMaskMapper_load')
+@KeepSymbol('ICU4XGeneralCategoryNameToMaskMapper_load')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XGeneralCategoryNameToMaskMapper_load')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/GraphemeClusterBreakIteratorLatin1.g.dart b/pkgs/intl4x/lib/src/bindings/GraphemeClusterBreakIteratorLatin1.g.dart
index 9a7f6f73..87f072e6 100644
--- a/pkgs/intl4x/lib/src/bindings/GraphemeClusterBreakIteratorLatin1.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/GraphemeClusterBreakIteratorLatin1.g.dart
@@ -36,14 +36,14 @@ final class GraphemeClusterBreakIteratorLatin1 implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XGraphemeClusterBreakIteratorLatin1_destroy')
+@KeepSymbol('ICU4XGraphemeClusterBreakIteratorLatin1_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XGraphemeClusterBreakIteratorLatin1_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XGraphemeClusterBreakIteratorLatin1_destroy(
     ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XGraphemeClusterBreakIteratorLatin1_next')
+@KeepSymbol('ICU4XGraphemeClusterBreakIteratorLatin1_next')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XGraphemeClusterBreakIteratorLatin1_next')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/GraphemeClusterBreakIteratorUtf16.g.dart b/pkgs/intl4x/lib/src/bindings/GraphemeClusterBreakIteratorUtf16.g.dart
index 8894f7dc..6ef828ab 100644
--- a/pkgs/intl4x/lib/src/bindings/GraphemeClusterBreakIteratorUtf16.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/GraphemeClusterBreakIteratorUtf16.g.dart
@@ -36,14 +36,14 @@ final class GraphemeClusterBreakIteratorUtf16 implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XGraphemeClusterBreakIteratorUtf16_destroy')
+@KeepSymbol('ICU4XGraphemeClusterBreakIteratorUtf16_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XGraphemeClusterBreakIteratorUtf16_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XGraphemeClusterBreakIteratorUtf16_destroy(
     ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XGraphemeClusterBreakIteratorUtf16_next')
+@KeepSymbol('ICU4XGraphemeClusterBreakIteratorUtf16_next')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XGraphemeClusterBreakIteratorUtf16_next')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/GraphemeClusterBreakIteratorUtf8.g.dart b/pkgs/intl4x/lib/src/bindings/GraphemeClusterBreakIteratorUtf8.g.dart
index 2e0ce350..8a96ea3f 100644
--- a/pkgs/intl4x/lib/src/bindings/GraphemeClusterBreakIteratorUtf8.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/GraphemeClusterBreakIteratorUtf8.g.dart
@@ -36,14 +36,14 @@ final class GraphemeClusterBreakIteratorUtf8 implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XGraphemeClusterBreakIteratorUtf8_destroy')
+@KeepSymbol('ICU4XGraphemeClusterBreakIteratorUtf8_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XGraphemeClusterBreakIteratorUtf8_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XGraphemeClusterBreakIteratorUtf8_destroy(
     ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XGraphemeClusterBreakIteratorUtf8_next')
+@KeepSymbol('ICU4XGraphemeClusterBreakIteratorUtf8_next')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XGraphemeClusterBreakIteratorUtf8_next')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/GraphemeClusterSegmenter.g.dart b/pkgs/intl4x/lib/src/bindings/GraphemeClusterSegmenter.g.dart
index 0f936e87..b997794a 100644
--- a/pkgs/intl4x/lib/src/bindings/GraphemeClusterSegmenter.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/GraphemeClusterSegmenter.g.dart
@@ -56,21 +56,21 @@ final class GraphemeClusterSegmenter implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XGraphemeClusterSegmenter_destroy')
+@KeepSymbol('ICU4XGraphemeClusterSegmenter_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XGraphemeClusterSegmenter_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XGraphemeClusterSegmenter_destroy(
     ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XGraphemeClusterSegmenter_create')
+@KeepSymbol('ICU4XGraphemeClusterSegmenter_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XGraphemeClusterSegmenter_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XGraphemeClusterSegmenter_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XGraphemeClusterSegmenter_segment_utf16')
+@KeepSymbol('ICU4XGraphemeClusterSegmenter_segment_utf16')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint16>, ffi.Size)>(
diff --git a/pkgs/intl4x/lib/src/bindings/GregorianDateFormatter.g.dart b/pkgs/intl4x/lib/src/bindings/GregorianDateFormatter.g.dart
index aebb225e..31e2bdc4 100644
--- a/pkgs/intl4x/lib/src/bindings/GregorianDateFormatter.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/GregorianDateFormatter.g.dart
@@ -72,13 +72,13 @@ final class GregorianDateFormatter implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XGregorianDateFormatter_destroy')
+@KeepSymbol('ICU4XGregorianDateFormatter_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XGregorianDateFormatter_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XGregorianDateFormatter_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XGregorianDateFormatter_create_with_length')
+@KeepSymbol('ICU4XGregorianDateFormatter_create_with_length')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>, ffi.Int32)>(
@@ -89,7 +89,7 @@ external _ResultOpaqueInt32 _ICU4XGregorianDateFormatter_create_with_length(
     ffi.Pointer<ffi.Opaque> locale,
     int length);
 
-@meta.ResourceIdentifier('ICU4XGregorianDateFormatter_format_iso_date')
+@KeepSymbol('ICU4XGregorianDateFormatter_format_iso_date')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -100,7 +100,7 @@ external _ResultVoidInt32 _ICU4XGregorianDateFormatter_format_iso_date(
     ffi.Pointer<ffi.Opaque> value,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XGregorianDateFormatter_format_iso_datetime')
+@KeepSymbol('ICU4XGregorianDateFormatter_format_iso_datetime')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/GregorianDateTimeFormatter.g.dart b/pkgs/intl4x/lib/src/bindings/GregorianDateTimeFormatter.g.dart
index ad7ce2f3..1072e04e 100644
--- a/pkgs/intl4x/lib/src/bindings/GregorianDateTimeFormatter.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/GregorianDateTimeFormatter.g.dart
@@ -57,14 +57,14 @@ final class GregorianDateTimeFormatter implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XGregorianDateTimeFormatter_destroy')
+@KeepSymbol('ICU4XGregorianDateTimeFormatter_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XGregorianDateTimeFormatter_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XGregorianDateTimeFormatter_destroy(
     ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XGregorianDateTimeFormatter_create_with_lengths')
+@KeepSymbol('ICU4XGregorianDateTimeFormatter_create_with_lengths')
 @ffi.Native<
         _ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Int32, ffi.Int32)>(
@@ -77,7 +77,7 @@ external _ResultOpaqueInt32
         int dateLength,
         int timeLength);
 
-@meta.ResourceIdentifier('ICU4XGregorianDateTimeFormatter_format_iso_datetime')
+@KeepSymbol('ICU4XGregorianDateTimeFormatter_format_iso_datetime')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/GregorianZonedDateTimeFormatter.g.dart b/pkgs/intl4x/lib/src/bindings/GregorianZonedDateTimeFormatter.g.dart
index 3f3ca8a3..dcd9439b 100644
--- a/pkgs/intl4x/lib/src/bindings/GregorianZonedDateTimeFormatter.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/GregorianZonedDateTimeFormatter.g.dart
@@ -90,15 +90,14 @@ final class GregorianZonedDateTimeFormatter implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XGregorianZonedDateTimeFormatter_destroy')
+@KeepSymbol('ICU4XGregorianZonedDateTimeFormatter_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XGregorianZonedDateTimeFormatter_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XGregorianZonedDateTimeFormatter_destroy(
     ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier(
-    'ICU4XGregorianZonedDateTimeFormatter_create_with_lengths')
+@KeepSymbol('ICU4XGregorianZonedDateTimeFormatter_create_with_lengths')
 @ffi.Native<
         _ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Int32, ffi.Int32)>(
@@ -112,7 +111,7 @@ external _ResultOpaqueInt32
         int dateLength,
         int timeLength);
 
-@meta.ResourceIdentifier(
+@KeepSymbol(
     'ICU4XGregorianZonedDateTimeFormatter_create_with_lengths_and_iso_8601_time_zone_fallback')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
@@ -133,7 +132,7 @@ external _ResultOpaqueInt32
         int timeLength,
         _IsoTimeZoneOptionsFfi zoneOptions);
 
-@meta.ResourceIdentifier(
+@KeepSymbol(
     'ICU4XGregorianZonedDateTimeFormatter_format_iso_datetime_with_custom_time_zone')
 @ffi.Native<
         _ResultVoidInt32 Function(
diff --git a/pkgs/intl4x/lib/src/bindings/IanaToBcp47Mapper.g.dart b/pkgs/intl4x/lib/src/bindings/IanaToBcp47Mapper.g.dart
index 40550aad..d77b9c90 100644
--- a/pkgs/intl4x/lib/src/bindings/IanaToBcp47Mapper.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/IanaToBcp47Mapper.g.dart
@@ -59,20 +59,20 @@ final class IanaToBcp47Mapper implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XIanaToBcp47Mapper_destroy')
+@KeepSymbol('ICU4XIanaToBcp47Mapper_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XIanaToBcp47Mapper_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XIanaToBcp47Mapper_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XIanaToBcp47Mapper_create')
+@KeepSymbol('ICU4XIanaToBcp47Mapper_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIanaToBcp47Mapper_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XIanaToBcp47Mapper_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XIanaToBcp47Mapper_get')
+@KeepSymbol('ICU4XIanaToBcp47Mapper_get')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Uint8>, ffi.Size, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/IsoDate.g.dart b/pkgs/intl4x/lib/src/bindings/IsoDate.g.dart
index 128dbdcb..1d3efdff 100644
--- a/pkgs/intl4x/lib/src/bindings/IsoDate.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/IsoDate.g.dart
@@ -157,25 +157,25 @@ final class IsoDate implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XIsoDate_destroy')
+@KeepSymbol('ICU4XIsoDate_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XIsoDate_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XIsoDate_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDate_create')
+@KeepSymbol('ICU4XIsoDate_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Int32, ffi.Uint8, ffi.Uint8)>(
     isLeaf: true, symbol: 'ICU4XIsoDate_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XIsoDate_create(int year, int month, int day);
 
-@meta.ResourceIdentifier('ICU4XIsoDate_create_for_unix_epoch')
+@KeepSymbol('ICU4XIsoDate_create_for_unix_epoch')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function()>(
     isLeaf: true, symbol: 'ICU4XIsoDate_create_for_unix_epoch')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XIsoDate_create_for_unix_epoch();
 
-@meta.ResourceIdentifier('ICU4XIsoDate_to_calendar')
+@KeepSymbol('ICU4XIsoDate_to_calendar')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -184,39 +184,39 @@ external ffi.Pointer<ffi.Opaque> _ICU4XIsoDate_create_for_unix_epoch();
 external ffi.Pointer<ffi.Opaque> _ICU4XIsoDate_to_calendar(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> calendar);
 
-@meta.ResourceIdentifier('ICU4XIsoDate_to_any')
+@KeepSymbol('ICU4XIsoDate_to_any')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDate_to_any')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XIsoDate_to_any(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDate_day_of_year')
+@KeepSymbol('ICU4XIsoDate_day_of_year')
 @ffi.Native<ffi.Uint16 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDate_day_of_year')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDate_day_of_year(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDate_day_of_month')
+@KeepSymbol('ICU4XIsoDate_day_of_month')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDate_day_of_month')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDate_day_of_month(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDate_day_of_week')
+@KeepSymbol('ICU4XIsoDate_day_of_week')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDate_day_of_week')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDate_day_of_week(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDate_week_of_month')
+@KeepSymbol('ICU4XIsoDate_week_of_month')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XIsoDate_week_of_month')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDate_week_of_month(
     ffi.Pointer<ffi.Opaque> self, int firstWeekday);
 
-@meta.ResourceIdentifier('ICU4XIsoDate_week_of_year')
+@KeepSymbol('ICU4XIsoDate_week_of_year')
 @ffi.Native<
         _ResultWeekOfFfiInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -225,37 +225,37 @@ external int _ICU4XIsoDate_week_of_month(
 external _ResultWeekOfFfiInt32 _ICU4XIsoDate_week_of_year(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> calculator);
 
-@meta.ResourceIdentifier('ICU4XIsoDate_month')
+@KeepSymbol('ICU4XIsoDate_month')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDate_month')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDate_month(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDate_year')
+@KeepSymbol('ICU4XIsoDate_year')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDate_year')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDate_year(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDate_is_in_leap_year')
+@KeepSymbol('ICU4XIsoDate_is_in_leap_year')
 @ffi.Native<ffi.Bool Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDate_is_in_leap_year')
 // ignore: non_constant_identifier_names
 external bool _ICU4XIsoDate_is_in_leap_year(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDate_months_in_year')
+@KeepSymbol('ICU4XIsoDate_months_in_year')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDate_months_in_year')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDate_months_in_year(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDate_days_in_month')
+@KeepSymbol('ICU4XIsoDate_days_in_month')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDate_days_in_month')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDate_days_in_month(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDate_days_in_year')
+@KeepSymbol('ICU4XIsoDate_days_in_year')
 @ffi.Native<ffi.Uint16 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDate_days_in_year')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/IsoDateTime.g.dart b/pkgs/intl4x/lib/src/bindings/IsoDateTime.g.dart
index 6e2b8ee7..eaa676d1 100644
--- a/pkgs/intl4x/lib/src/bindings/IsoDateTime.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/IsoDateTime.g.dart
@@ -236,13 +236,13 @@ final class IsoDateTime implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_destroy')
+@KeepSymbol('ICU4XIsoDateTime_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XIsoDateTime_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_create')
+@KeepSymbol('ICU4XIsoDateTime_create')
 @ffi.Native<
     _ResultOpaqueInt32 Function(
         ffi.Int32,
@@ -256,7 +256,7 @@ external void _ICU4XIsoDateTime_destroy(ffi.Pointer<ffi.Void> self);
 external _ResultOpaqueInt32 _ICU4XIsoDateTime_create(int year, int month,
     int day, int hour, int minute, int second, int nanosecond);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_crate_from_date_and_time')
+@KeepSymbol('ICU4XIsoDateTime_crate_from_date_and_time')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -265,14 +265,13 @@ external _ResultOpaqueInt32 _ICU4XIsoDateTime_create(int year, int month,
 external ffi.Pointer<ffi.Opaque> _ICU4XIsoDateTime_crate_from_date_and_time(
     ffi.Pointer<ffi.Opaque> date, ffi.Pointer<ffi.Opaque> time);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_local_unix_epoch')
+@KeepSymbol('ICU4XIsoDateTime_local_unix_epoch')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function()>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_local_unix_epoch')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XIsoDateTime_local_unix_epoch();
 
-@meta.ResourceIdentifier(
-    'ICU4XIsoDateTime_create_from_minutes_since_local_unix_epoch')
+@KeepSymbol('ICU4XIsoDateTime_create_from_minutes_since_local_unix_epoch')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Int32)>(
     isLeaf: true,
     symbol: 'ICU4XIsoDateTime_create_from_minutes_since_local_unix_epoch')
@@ -280,35 +279,35 @@ external ffi.Pointer<ffi.Opaque> _ICU4XIsoDateTime_local_unix_epoch();
 external ffi.Pointer<ffi.Opaque>
     _ICU4XIsoDateTime_create_from_minutes_since_local_unix_epoch(int minutes);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_date')
+@KeepSymbol('ICU4XIsoDateTime_date')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_date')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XIsoDateTime_date(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_time')
+@KeepSymbol('ICU4XIsoDateTime_time')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_time')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XIsoDateTime_time(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_to_any')
+@KeepSymbol('ICU4XIsoDateTime_to_any')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_to_any')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XIsoDateTime_to_any(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_minutes_since_local_unix_epoch')
+@KeepSymbol('ICU4XIsoDateTime_minutes_since_local_unix_epoch')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_minutes_since_local_unix_epoch')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDateTime_minutes_since_local_unix_epoch(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_to_calendar')
+@KeepSymbol('ICU4XIsoDateTime_to_calendar')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -317,56 +316,56 @@ external int _ICU4XIsoDateTime_minutes_since_local_unix_epoch(
 external ffi.Pointer<ffi.Opaque> _ICU4XIsoDateTime_to_calendar(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> calendar);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_hour')
+@KeepSymbol('ICU4XIsoDateTime_hour')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_hour')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDateTime_hour(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_minute')
+@KeepSymbol('ICU4XIsoDateTime_minute')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_minute')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDateTime_minute(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_second')
+@KeepSymbol('ICU4XIsoDateTime_second')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_second')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDateTime_second(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_nanosecond')
+@KeepSymbol('ICU4XIsoDateTime_nanosecond')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_nanosecond')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDateTime_nanosecond(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_day_of_year')
+@KeepSymbol('ICU4XIsoDateTime_day_of_year')
 @ffi.Native<ffi.Uint16 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_day_of_year')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDateTime_day_of_year(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_day_of_month')
+@KeepSymbol('ICU4XIsoDateTime_day_of_month')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_day_of_month')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDateTime_day_of_month(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_day_of_week')
+@KeepSymbol('ICU4XIsoDateTime_day_of_week')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_day_of_week')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDateTime_day_of_week(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_week_of_month')
+@KeepSymbol('ICU4XIsoDateTime_week_of_month')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>, ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_week_of_month')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDateTime_week_of_month(
     ffi.Pointer<ffi.Opaque> self, int firstWeekday);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_week_of_year')
+@KeepSymbol('ICU4XIsoDateTime_week_of_year')
 @ffi.Native<
         _ResultWeekOfFfiInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -375,37 +374,37 @@ external int _ICU4XIsoDateTime_week_of_month(
 external _ResultWeekOfFfiInt32 _ICU4XIsoDateTime_week_of_year(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> calculator);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_month')
+@KeepSymbol('ICU4XIsoDateTime_month')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_month')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDateTime_month(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_year')
+@KeepSymbol('ICU4XIsoDateTime_year')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_year')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDateTime_year(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_is_in_leap_year')
+@KeepSymbol('ICU4XIsoDateTime_is_in_leap_year')
 @ffi.Native<ffi.Bool Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_is_in_leap_year')
 // ignore: non_constant_identifier_names
 external bool _ICU4XIsoDateTime_is_in_leap_year(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_months_in_year')
+@KeepSymbol('ICU4XIsoDateTime_months_in_year')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_months_in_year')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDateTime_months_in_year(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_days_in_month')
+@KeepSymbol('ICU4XIsoDateTime_days_in_month')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_days_in_month')
 // ignore: non_constant_identifier_names
 external int _ICU4XIsoDateTime_days_in_month(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XIsoDateTime_days_in_year')
+@KeepSymbol('ICU4XIsoDateTime_days_in_year')
 @ffi.Native<ffi.Uint16 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XIsoDateTime_days_in_year')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/LineBreakIteratorLatin1.g.dart b/pkgs/intl4x/lib/src/bindings/LineBreakIteratorLatin1.g.dart
index 10d08d46..2d72e8d4 100644
--- a/pkgs/intl4x/lib/src/bindings/LineBreakIteratorLatin1.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/LineBreakIteratorLatin1.g.dart
@@ -37,13 +37,13 @@ final class LineBreakIteratorLatin1 implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XLineBreakIteratorLatin1_destroy')
+@KeepSymbol('ICU4XLineBreakIteratorLatin1_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XLineBreakIteratorLatin1_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XLineBreakIteratorLatin1_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XLineBreakIteratorLatin1_next')
+@KeepSymbol('ICU4XLineBreakIteratorLatin1_next')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLineBreakIteratorLatin1_next')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/LineBreakIteratorUtf16.g.dart b/pkgs/intl4x/lib/src/bindings/LineBreakIteratorUtf16.g.dart
index d7d506a1..e42b7170 100644
--- a/pkgs/intl4x/lib/src/bindings/LineBreakIteratorUtf16.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/LineBreakIteratorUtf16.g.dart
@@ -37,13 +37,13 @@ final class LineBreakIteratorUtf16 implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XLineBreakIteratorUtf16_destroy')
+@KeepSymbol('ICU4XLineBreakIteratorUtf16_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XLineBreakIteratorUtf16_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XLineBreakIteratorUtf16_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XLineBreakIteratorUtf16_next')
+@KeepSymbol('ICU4XLineBreakIteratorUtf16_next')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLineBreakIteratorUtf16_next')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/LineBreakIteratorUtf8.g.dart b/pkgs/intl4x/lib/src/bindings/LineBreakIteratorUtf8.g.dart
index 4a2db823..80554361 100644
--- a/pkgs/intl4x/lib/src/bindings/LineBreakIteratorUtf8.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/LineBreakIteratorUtf8.g.dart
@@ -37,13 +37,13 @@ final class LineBreakIteratorUtf8 implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XLineBreakIteratorUtf8_destroy')
+@KeepSymbol('ICU4XLineBreakIteratorUtf8_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XLineBreakIteratorUtf8_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XLineBreakIteratorUtf8_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XLineBreakIteratorUtf8_next')
+@KeepSymbol('ICU4XLineBreakIteratorUtf8_next')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLineBreakIteratorUtf8_next')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/LineSegmenter.g.dart b/pkgs/intl4x/lib/src/bindings/LineSegmenter.g.dart
index 1b171d6a..6765c7e7 100644
--- a/pkgs/intl4x/lib/src/bindings/LineSegmenter.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/LineSegmenter.g.dart
@@ -138,34 +138,34 @@ final class LineSegmenter implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XLineSegmenter_destroy')
+@KeepSymbol('ICU4XLineSegmenter_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XLineSegmenter_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XLineSegmenter_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XLineSegmenter_create_auto')
+@KeepSymbol('ICU4XLineSegmenter_create_auto')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLineSegmenter_create_auto')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XLineSegmenter_create_auto(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XLineSegmenter_create_lstm')
+@KeepSymbol('ICU4XLineSegmenter_create_lstm')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLineSegmenter_create_lstm')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XLineSegmenter_create_lstm(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XLineSegmenter_create_dictionary')
+@KeepSymbol('ICU4XLineSegmenter_create_dictionary')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLineSegmenter_create_dictionary')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XLineSegmenter_create_dictionary(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XLineSegmenter_create_auto_with_options_v1')
+@KeepSymbol('ICU4XLineSegmenter_create_auto_with_options_v1')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, _LineBreakOptionsFfi)>(
@@ -174,7 +174,7 @@ external _ResultOpaqueInt32 _ICU4XLineSegmenter_create_dictionary(
 external _ResultOpaqueInt32 _ICU4XLineSegmenter_create_auto_with_options_v1(
     ffi.Pointer<ffi.Opaque> provider, _LineBreakOptionsFfi options);
 
-@meta.ResourceIdentifier('ICU4XLineSegmenter_create_lstm_with_options_v1')
+@KeepSymbol('ICU4XLineSegmenter_create_lstm_with_options_v1')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, _LineBreakOptionsFfi)>(
@@ -183,7 +183,7 @@ external _ResultOpaqueInt32 _ICU4XLineSegmenter_create_auto_with_options_v1(
 external _ResultOpaqueInt32 _ICU4XLineSegmenter_create_lstm_with_options_v1(
     ffi.Pointer<ffi.Opaque> provider, _LineBreakOptionsFfi options);
 
-@meta.ResourceIdentifier('ICU4XLineSegmenter_create_dictionary_with_options_v1')
+@KeepSymbol('ICU4XLineSegmenter_create_dictionary_with_options_v1')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, _LineBreakOptionsFfi)>(
@@ -194,7 +194,7 @@ external _ResultOpaqueInt32
     _ICU4XLineSegmenter_create_dictionary_with_options_v1(
         ffi.Pointer<ffi.Opaque> provider, _LineBreakOptionsFfi options);
 
-@meta.ResourceIdentifier('ICU4XLineSegmenter_segment_utf16')
+@KeepSymbol('ICU4XLineSegmenter_segment_utf16')
 @ffi.Native<
     ffi.Pointer<ffi.Opaque> Function(
         ffi.Pointer<ffi.Opaque>,
diff --git a/pkgs/intl4x/lib/src/bindings/ListFormatter.g.dart b/pkgs/intl4x/lib/src/bindings/ListFormatter.g.dart
index 8edf8517..fe9b992d 100644
--- a/pkgs/intl4x/lib/src/bindings/ListFormatter.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/ListFormatter.g.dart
@@ -85,13 +85,13 @@ final class ListFormatter implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XListFormatter_destroy')
+@KeepSymbol('ICU4XListFormatter_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XListFormatter_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XListFormatter_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XListFormatter_create_and_with_length')
+@KeepSymbol('ICU4XListFormatter_create_and_with_length')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>, ffi.Int32)>(
@@ -102,7 +102,7 @@ external _ResultOpaqueInt32 _ICU4XListFormatter_create_and_with_length(
     ffi.Pointer<ffi.Opaque> locale,
     int length);
 
-@meta.ResourceIdentifier('ICU4XListFormatter_create_or_with_length')
+@KeepSymbol('ICU4XListFormatter_create_or_with_length')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>, ffi.Int32)>(
@@ -113,7 +113,7 @@ external _ResultOpaqueInt32 _ICU4XListFormatter_create_or_with_length(
     ffi.Pointer<ffi.Opaque> locale,
     int length);
 
-@meta.ResourceIdentifier('ICU4XListFormatter_create_unit_with_length')
+@KeepSymbol('ICU4XListFormatter_create_unit_with_length')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>, ffi.Int32)>(
@@ -124,7 +124,7 @@ external _ResultOpaqueInt32 _ICU4XListFormatter_create_unit_with_length(
     ffi.Pointer<ffi.Opaque> locale,
     int length);
 
-@meta.ResourceIdentifier('ICU4XListFormatter_format_utf16')
+@KeepSymbol('ICU4XListFormatter_format_utf16')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<_SliceUtf16>, ffi.Size, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/Locale.g.dart b/pkgs/intl4x/lib/src/bindings/Locale.g.dart
index 9720511f..fda9df35 100644
--- a/pkgs/intl4x/lib/src/bindings/Locale.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/Locale.g.dart
@@ -253,33 +253,33 @@ final class Locale implements ffi.Finalizable, core.Comparable<Locale> {
       42; // Cannot get hash from Rust, so a constant is the only correct impl
 }
 
-@meta.ResourceIdentifier('ICU4XLocale_destroy')
+@KeepSymbol('ICU4XLocale_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XLocale_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XLocale_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XLocale_create_from_string')
+@KeepSymbol('ICU4XLocale_create_from_string')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Uint8>, ffi.Size)>(
     isLeaf: true, symbol: 'ICU4XLocale_create_from_string')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XLocale_create_from_string(
     ffi.Pointer<ffi.Uint8> nameData, int nameLength);
 
-@meta.ResourceIdentifier('ICU4XLocale_create_und')
+@KeepSymbol('ICU4XLocale_create_und')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function()>(
     isLeaf: true, symbol: 'ICU4XLocale_create_und')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XLocale_create_und();
 
-@meta.ResourceIdentifier('ICU4XLocale_clone')
+@KeepSymbol('ICU4XLocale_clone')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLocale_clone')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XLocale_clone(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XLocale_basename')
+@KeepSymbol('ICU4XLocale_basename')
 @ffi.Native<
     _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
         ffi.Pointer<ffi.Opaque>)>(isLeaf: true, symbol: 'ICU4XLocale_basename')
@@ -287,7 +287,7 @@ external ffi.Pointer<ffi.Opaque> _ICU4XLocale_clone(
 external _ResultVoidInt32 _ICU4XLocale_basename(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XLocale_get_unicode_extension')
+@KeepSymbol('ICU4XLocale_get_unicode_extension')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Uint8>, ffi.Size, ffi.Pointer<ffi.Opaque>)>(
@@ -299,7 +299,7 @@ external _ResultVoidInt32 _ICU4XLocale_get_unicode_extension(
     int bytesLength,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XLocale_language')
+@KeepSymbol('ICU4XLocale_language')
 @ffi.Native<
     _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
         ffi.Pointer<ffi.Opaque>)>(isLeaf: true, symbol: 'ICU4XLocale_language')
@@ -307,7 +307,7 @@ external _ResultVoidInt32 _ICU4XLocale_get_unicode_extension(
 external _ResultVoidInt32 _ICU4XLocale_language(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XLocale_set_language')
+@KeepSymbol('ICU4XLocale_set_language')
 @ffi.Native<
     _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>,
         ffi.Size)>(isLeaf: true, symbol: 'ICU4XLocale_set_language')
@@ -317,7 +317,7 @@ external _ResultVoidInt32 _ICU4XLocale_set_language(
     ffi.Pointer<ffi.Uint8> bytesData,
     int bytesLength);
 
-@meta.ResourceIdentifier('ICU4XLocale_region')
+@KeepSymbol('ICU4XLocale_region')
 @ffi.Native<
     _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
         ffi.Pointer<ffi.Opaque>)>(isLeaf: true, symbol: 'ICU4XLocale_region')
@@ -325,7 +325,7 @@ external _ResultVoidInt32 _ICU4XLocale_set_language(
 external _ResultVoidInt32 _ICU4XLocale_region(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XLocale_set_region')
+@KeepSymbol('ICU4XLocale_set_region')
 @ffi.Native<
     _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>,
         ffi.Size)>(isLeaf: true, symbol: 'ICU4XLocale_set_region')
@@ -333,7 +333,7 @@ external _ResultVoidInt32 _ICU4XLocale_region(
 external _ResultVoidInt32 _ICU4XLocale_set_region(ffi.Pointer<ffi.Opaque> self,
     ffi.Pointer<ffi.Uint8> bytesData, int bytesLength);
 
-@meta.ResourceIdentifier('ICU4XLocale_script')
+@KeepSymbol('ICU4XLocale_script')
 @ffi.Native<
     _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
         ffi.Pointer<ffi.Opaque>)>(isLeaf: true, symbol: 'ICU4XLocale_script')
@@ -341,7 +341,7 @@ external _ResultVoidInt32 _ICU4XLocale_set_region(ffi.Pointer<ffi.Opaque> self,
 external _ResultVoidInt32 _ICU4XLocale_script(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XLocale_set_script')
+@KeepSymbol('ICU4XLocale_set_script')
 @ffi.Native<
     _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>,
         ffi.Size)>(isLeaf: true, symbol: 'ICU4XLocale_set_script')
@@ -349,7 +349,7 @@ external _ResultVoidInt32 _ICU4XLocale_script(
 external _ResultVoidInt32 _ICU4XLocale_set_script(ffi.Pointer<ffi.Opaque> self,
     ffi.Pointer<ffi.Uint8> bytesData, int bytesLength);
 
-@meta.ResourceIdentifier('ICU4XLocale_canonicalize')
+@KeepSymbol('ICU4XLocale_canonicalize')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Uint8>, ffi.Size, ffi.Pointer<ffi.Opaque>)>(
@@ -360,7 +360,7 @@ external _ResultVoidInt32 _ICU4XLocale_canonicalize(
     int bytesLength,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XLocale_to_string')
+@KeepSymbol('ICU4XLocale_to_string')
 @ffi.Native<
     _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
         ffi.Pointer<ffi.Opaque>)>(isLeaf: true, symbol: 'ICU4XLocale_to_string')
@@ -368,7 +368,7 @@ external _ResultVoidInt32 _ICU4XLocale_canonicalize(
 external _ResultVoidInt32 _ICU4XLocale_to_string(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XLocale_normalizing_eq')
+@KeepSymbol('ICU4XLocale_normalizing_eq')
 @ffi.Native<
     ffi.Bool Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>,
         ffi.Size)>(isLeaf: true, symbol: 'ICU4XLocale_normalizing_eq')
@@ -376,7 +376,7 @@ external _ResultVoidInt32 _ICU4XLocale_to_string(
 external bool _ICU4XLocale_normalizing_eq(ffi.Pointer<ffi.Opaque> self,
     ffi.Pointer<ffi.Uint8> otherData, int otherLength);
 
-@meta.ResourceIdentifier('ICU4XLocale_strict_cmp_')
+@KeepSymbol('ICU4XLocale_strict_cmp_')
 @ffi.Native<
     ffi.Int8 Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>,
         ffi.Size)>(isLeaf: true, symbol: 'ICU4XLocale_strict_cmp_')
@@ -384,7 +384,7 @@ external bool _ICU4XLocale_normalizing_eq(ffi.Pointer<ffi.Opaque> self,
 external int _ICU4XLocale_strict_cmp_(ffi.Pointer<ffi.Opaque> self,
     ffi.Pointer<ffi.Uint8> otherData, int otherLength);
 
-@meta.ResourceIdentifier('ICU4XLocale_total_cmp_')
+@KeepSymbol('ICU4XLocale_total_cmp_')
 @ffi.Native<
         ffi.Int8 Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLocale_total_cmp_')
diff --git a/pkgs/intl4x/lib/src/bindings/LocaleCanonicalizer.g.dart b/pkgs/intl4x/lib/src/bindings/LocaleCanonicalizer.g.dart
index 2c0bbc74..41ade50f 100644
--- a/pkgs/intl4x/lib/src/bindings/LocaleCanonicalizer.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/LocaleCanonicalizer.g.dart
@@ -58,27 +58,27 @@ final class LocaleCanonicalizer implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XLocaleCanonicalizer_destroy')
+@KeepSymbol('ICU4XLocaleCanonicalizer_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XLocaleCanonicalizer_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XLocaleCanonicalizer_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XLocaleCanonicalizer_create')
+@KeepSymbol('ICU4XLocaleCanonicalizer_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLocaleCanonicalizer_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XLocaleCanonicalizer_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XLocaleCanonicalizer_create_extended')
+@KeepSymbol('ICU4XLocaleCanonicalizer_create_extended')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLocaleCanonicalizer_create_extended')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XLocaleCanonicalizer_create_extended(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XLocaleCanonicalizer_canonicalize')
+@KeepSymbol('ICU4XLocaleCanonicalizer_canonicalize')
 @ffi.Native<
         ffi.Int32 Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLocaleCanonicalizer_canonicalize')
diff --git a/pkgs/intl4x/lib/src/bindings/LocaleDirectionality.g.dart b/pkgs/intl4x/lib/src/bindings/LocaleDirectionality.g.dart
index 93e9bf4b..06d48f3a 100644
--- a/pkgs/intl4x/lib/src/bindings/LocaleDirectionality.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/LocaleDirectionality.g.dart
@@ -72,20 +72,20 @@ final class LocaleDirectionality implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XLocaleDirectionality_destroy')
+@KeepSymbol('ICU4XLocaleDirectionality_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XLocaleDirectionality_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XLocaleDirectionality_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XLocaleDirectionality_create')
+@KeepSymbol('ICU4XLocaleDirectionality_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLocaleDirectionality_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XLocaleDirectionality_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XLocaleDirectionality_create_with_expander')
+@KeepSymbol('ICU4XLocaleDirectionality_create_with_expander')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -94,7 +94,7 @@ external _ResultOpaqueInt32 _ICU4XLocaleDirectionality_create(
 external _ResultOpaqueInt32 _ICU4XLocaleDirectionality_create_with_expander(
     ffi.Pointer<ffi.Opaque> provider, ffi.Pointer<ffi.Opaque> expander);
 
-@meta.ResourceIdentifier('ICU4XLocaleDirectionality_get')
+@KeepSymbol('ICU4XLocaleDirectionality_get')
 @ffi.Native<
         ffi.Int32 Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLocaleDirectionality_get')
@@ -102,7 +102,7 @@ external _ResultOpaqueInt32 _ICU4XLocaleDirectionality_create_with_expander(
 external int _ICU4XLocaleDirectionality_get(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> locale);
 
-@meta.ResourceIdentifier('ICU4XLocaleDirectionality_is_left_to_right')
+@KeepSymbol('ICU4XLocaleDirectionality_is_left_to_right')
 @ffi.Native<
         ffi.Bool Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLocaleDirectionality_is_left_to_right')
@@ -110,7 +110,7 @@ external int _ICU4XLocaleDirectionality_get(
 external bool _ICU4XLocaleDirectionality_is_left_to_right(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> locale);
 
-@meta.ResourceIdentifier('ICU4XLocaleDirectionality_is_right_to_left')
+@KeepSymbol('ICU4XLocaleDirectionality_is_right_to_left')
 @ffi.Native<
         ffi.Bool Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLocaleDirectionality_is_right_to_left')
diff --git a/pkgs/intl4x/lib/src/bindings/LocaleDisplayNamesFormatter.g.dart b/pkgs/intl4x/lib/src/bindings/LocaleDisplayNamesFormatter.g.dart
index 72231e10..abbf7c5c 100644
--- a/pkgs/intl4x/lib/src/bindings/LocaleDisplayNamesFormatter.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/LocaleDisplayNamesFormatter.g.dart
@@ -56,14 +56,14 @@ final class LocaleDisplayNamesFormatter implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XLocaleDisplayNamesFormatter_destroy')
+@KeepSymbol('ICU4XLocaleDisplayNamesFormatter_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XLocaleDisplayNamesFormatter_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XLocaleDisplayNamesFormatter_destroy(
     ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XLocaleDisplayNamesFormatter_create')
+@KeepSymbol('ICU4XLocaleDisplayNamesFormatter_create')
 @ffi.Native<
         _ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, _DisplayNamesOptionsFfi)>(
@@ -74,7 +74,7 @@ external _ResultOpaqueInt32 _ICU4XLocaleDisplayNamesFormatter_create(
     ffi.Pointer<ffi.Opaque> locale,
     _DisplayNamesOptionsFfi options);
 
-@meta.ResourceIdentifier('ICU4XLocaleDisplayNamesFormatter_of')
+@KeepSymbol('ICU4XLocaleDisplayNamesFormatter_of')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/LocaleExpander.g.dart b/pkgs/intl4x/lib/src/bindings/LocaleExpander.g.dart
index 5c825eac..8411e50b 100644
--- a/pkgs/intl4x/lib/src/bindings/LocaleExpander.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/LocaleExpander.g.dart
@@ -71,27 +71,27 @@ final class LocaleExpander implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XLocaleExpander_destroy')
+@KeepSymbol('ICU4XLocaleExpander_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XLocaleExpander_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XLocaleExpander_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XLocaleExpander_create')
+@KeepSymbol('ICU4XLocaleExpander_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLocaleExpander_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XLocaleExpander_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XLocaleExpander_create_extended')
+@KeepSymbol('ICU4XLocaleExpander_create_extended')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLocaleExpander_create_extended')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XLocaleExpander_create_extended(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XLocaleExpander_maximize')
+@KeepSymbol('ICU4XLocaleExpander_maximize')
 @ffi.Native<
         ffi.Int32 Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLocaleExpander_maximize')
@@ -99,7 +99,7 @@ external _ResultOpaqueInt32 _ICU4XLocaleExpander_create_extended(
 external int _ICU4XLocaleExpander_maximize(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> locale);
 
-@meta.ResourceIdentifier('ICU4XLocaleExpander_minimize')
+@KeepSymbol('ICU4XLocaleExpander_minimize')
 @ffi.Native<
         ffi.Int32 Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLocaleExpander_minimize')
@@ -107,7 +107,7 @@ external int _ICU4XLocaleExpander_maximize(
 external int _ICU4XLocaleExpander_minimize(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> locale);
 
-@meta.ResourceIdentifier('ICU4XLocaleExpander_minimize_favor_script')
+@KeepSymbol('ICU4XLocaleExpander_minimize_favor_script')
 @ffi.Native<
         ffi.Int32 Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLocaleExpander_minimize_favor_script')
diff --git a/pkgs/intl4x/lib/src/bindings/LocaleFallbackIterator.g.dart b/pkgs/intl4x/lib/src/bindings/LocaleFallbackIterator.g.dart
index 91aa763a..7e0e817a 100644
--- a/pkgs/intl4x/lib/src/bindings/LocaleFallbackIterator.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/LocaleFallbackIterator.g.dart
@@ -45,13 +45,13 @@ final class LocaleFallbackIterator
   }
 }
 
-@meta.ResourceIdentifier('ICU4XLocaleFallbackIterator_destroy')
+@KeepSymbol('ICU4XLocaleFallbackIterator_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XLocaleFallbackIterator_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XLocaleFallbackIterator_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XLocaleFallbackIterator_next')
+@KeepSymbol('ICU4XLocaleFallbackIterator_next')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLocaleFallbackIterator_next')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/LocaleFallbacker.g.dart b/pkgs/intl4x/lib/src/bindings/LocaleFallbacker.g.dart
index 7fc24d61..b82c50e8 100644
--- a/pkgs/intl4x/lib/src/bindings/LocaleFallbacker.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/LocaleFallbacker.g.dart
@@ -64,26 +64,26 @@ final class LocaleFallbacker implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XLocaleFallbacker_destroy')
+@KeepSymbol('ICU4XLocaleFallbacker_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XLocaleFallbacker_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XLocaleFallbacker_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XLocaleFallbacker_create')
+@KeepSymbol('ICU4XLocaleFallbacker_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XLocaleFallbacker_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XLocaleFallbacker_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XLocaleFallbacker_create_without_data')
+@KeepSymbol('ICU4XLocaleFallbacker_create_without_data')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function()>(
     isLeaf: true, symbol: 'ICU4XLocaleFallbacker_create_without_data')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XLocaleFallbacker_create_without_data();
 
-@meta.ResourceIdentifier('ICU4XLocaleFallbacker_for_config')
+@KeepSymbol('ICU4XLocaleFallbacker_for_config')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, _LocaleFallbackConfigFfi)>(
diff --git a/pkgs/intl4x/lib/src/bindings/LocaleFallbackerWithConfig.g.dart b/pkgs/intl4x/lib/src/bindings/LocaleFallbackerWithConfig.g.dart
index b84a7a1e..e527607f 100644
--- a/pkgs/intl4x/lib/src/bindings/LocaleFallbackerWithConfig.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/LocaleFallbackerWithConfig.g.dart
@@ -41,14 +41,14 @@ final class LocaleFallbackerWithConfig implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XLocaleFallbackerWithConfig_destroy')
+@KeepSymbol('ICU4XLocaleFallbackerWithConfig_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XLocaleFallbackerWithConfig_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XLocaleFallbackerWithConfig_destroy(
     ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XLocaleFallbackerWithConfig_fallback_for_locale')
+@KeepSymbol('ICU4XLocaleFallbackerWithConfig_fallback_for_locale')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/Logger.g.dart b/pkgs/intl4x/lib/src/bindings/Logger.g.dart
index 93a94aa3..c1cf0358 100644
--- a/pkgs/intl4x/lib/src/bindings/Logger.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/Logger.g.dart
@@ -40,19 +40,19 @@ final class Logger implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XLogger_destroy')
+@KeepSymbol('ICU4XLogger_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XLogger_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XLogger_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XLogger_init_simple_logger')
+@KeepSymbol('ICU4XLogger_init_simple_logger')
 @ffi.Native<ffi.Bool Function()>(
     isLeaf: true, symbol: 'ICU4XLogger_init_simple_logger')
 // ignore: non_constant_identifier_names
 external bool _ICU4XLogger_init_simple_logger();
 
-@meta.ResourceIdentifier('ICU4XLogger_init_console_logger')
+@KeepSymbol('ICU4XLogger_init_console_logger')
 @ffi.Native<ffi.Bool Function()>(
     isLeaf: true, symbol: 'ICU4XLogger_init_console_logger')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/MeasureUnit.g.dart b/pkgs/intl4x/lib/src/bindings/MeasureUnit.g.dart
index de3ab053..ce03fa82 100644
--- a/pkgs/intl4x/lib/src/bindings/MeasureUnit.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/MeasureUnit.g.dart
@@ -29,7 +29,7 @@ final class MeasureUnit implements ffi.Finalizable {
       ffi.NativeFinalizer(ffi.Native.addressOf(_ICU4XMeasureUnit_destroy));
 }
 
-@meta.ResourceIdentifier('ICU4XMeasureUnit_destroy')
+@KeepSymbol('ICU4XMeasureUnit_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XMeasureUnit_destroy')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/MeasureUnitParser.g.dart b/pkgs/intl4x/lib/src/bindings/MeasureUnitParser.g.dart
index 3c4c0143..86b86174 100644
--- a/pkgs/intl4x/lib/src/bindings/MeasureUnitParser.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/MeasureUnitParser.g.dart
@@ -47,13 +47,13 @@ final class MeasureUnitParser implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XMeasureUnitParser_destroy')
+@KeepSymbol('ICU4XMeasureUnitParser_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XMeasureUnitParser_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XMeasureUnitParser_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XMeasureUnitParser_parse')
+@KeepSymbol('ICU4XMeasureUnitParser_parse')
 @ffi.Native<
     _ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>,
         ffi.Size)>(isLeaf: true, symbol: 'ICU4XMeasureUnitParser_parse')
diff --git a/pkgs/intl4x/lib/src/bindings/MetazoneCalculator.g.dart b/pkgs/intl4x/lib/src/bindings/MetazoneCalculator.g.dart
index 00bd4436..f41bd9f5 100644
--- a/pkgs/intl4x/lib/src/bindings/MetazoneCalculator.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/MetazoneCalculator.g.dart
@@ -41,13 +41,13 @@ final class MetazoneCalculator implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XMetazoneCalculator_destroy')
+@KeepSymbol('ICU4XMetazoneCalculator_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XMetazoneCalculator_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XMetazoneCalculator_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XMetazoneCalculator_create')
+@KeepSymbol('ICU4XMetazoneCalculator_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XMetazoneCalculator_create')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/PluralCategory.g.dart b/pkgs/intl4x/lib/src/bindings/PluralCategory.g.dart
index d26000c4..3941734c 100644
--- a/pkgs/intl4x/lib/src/bindings/PluralCategory.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/PluralCategory.g.dart
@@ -35,7 +35,7 @@ enum PluralCategory {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XPluralCategory_get_for_cldr_string')
+@KeepSymbol('ICU4XPluralCategory_get_for_cldr_string')
 @ffi.Native<_ResultInt32Void Function(ffi.Pointer<ffi.Uint8>, ffi.Size)>(
     isLeaf: true, symbol: 'ICU4XPluralCategory_get_for_cldr_string')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/PluralOperands.g.dart b/pkgs/intl4x/lib/src/bindings/PluralOperands.g.dart
index a660de27..cc32ea22 100644
--- a/pkgs/intl4x/lib/src/bindings/PluralOperands.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/PluralOperands.g.dart
@@ -49,20 +49,20 @@ final class PluralOperands implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XPluralOperands_destroy')
+@KeepSymbol('ICU4XPluralOperands_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XPluralOperands_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XPluralOperands_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XPluralOperands_create_from_string')
+@KeepSymbol('ICU4XPluralOperands_create_from_string')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Uint8>, ffi.Size)>(
     isLeaf: true, symbol: 'ICU4XPluralOperands_create_from_string')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XPluralOperands_create_from_string(
     ffi.Pointer<ffi.Uint8> sData, int sLength);
 
-@meta.ResourceIdentifier('ICU4XPluralOperands_create_from_fixed_decimal')
+@KeepSymbol('ICU4XPluralOperands_create_from_fixed_decimal')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XPluralOperands_create_from_fixed_decimal')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/PluralRules.g.dart b/pkgs/intl4x/lib/src/bindings/PluralRules.g.dart
index af7d39a7..25f1ec71 100644
--- a/pkgs/intl4x/lib/src/bindings/PluralRules.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/PluralRules.g.dart
@@ -67,13 +67,13 @@ final class PluralRules implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XPluralRules_destroy')
+@KeepSymbol('ICU4XPluralRules_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XPluralRules_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XPluralRules_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XPluralRules_create_cardinal')
+@KeepSymbol('ICU4XPluralRules_create_cardinal')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -82,7 +82,7 @@ external void _ICU4XPluralRules_destroy(ffi.Pointer<ffi.Void> self);
 external _ResultOpaqueInt32 _ICU4XPluralRules_create_cardinal(
     ffi.Pointer<ffi.Opaque> provider, ffi.Pointer<ffi.Opaque> locale);
 
-@meta.ResourceIdentifier('ICU4XPluralRules_create_ordinal')
+@KeepSymbol('ICU4XPluralRules_create_ordinal')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -91,7 +91,7 @@ external _ResultOpaqueInt32 _ICU4XPluralRules_create_cardinal(
 external _ResultOpaqueInt32 _ICU4XPluralRules_create_ordinal(
     ffi.Pointer<ffi.Opaque> provider, ffi.Pointer<ffi.Opaque> locale);
 
-@meta.ResourceIdentifier('ICU4XPluralRules_category_for')
+@KeepSymbol('ICU4XPluralRules_category_for')
 @ffi.Native<
         ffi.Int32 Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XPluralRules_category_for')
@@ -99,7 +99,7 @@ external _ResultOpaqueInt32 _ICU4XPluralRules_create_ordinal(
 external int _ICU4XPluralRules_category_for(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> op);
 
-@meta.ResourceIdentifier('ICU4XPluralRules_categories')
+@KeepSymbol('ICU4XPluralRules_categories')
 @ffi.Native<_PluralCategoriesFfi Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XPluralRules_categories')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/PropertyValueNameToEnumMapper.g.dart b/pkgs/intl4x/lib/src/bindings/PropertyValueNameToEnumMapper.g.dart
index f4c7f166..61574fa6 100644
--- a/pkgs/intl4x/lib/src/bindings/PropertyValueNameToEnumMapper.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/PropertyValueNameToEnumMapper.g.dart
@@ -182,14 +182,14 @@ final class PropertyValueNameToEnumMapper implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XPropertyValueNameToEnumMapper_destroy')
+@KeepSymbol('ICU4XPropertyValueNameToEnumMapper_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XPropertyValueNameToEnumMapper_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XPropertyValueNameToEnumMapper_destroy(
     ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XPropertyValueNameToEnumMapper_get_strict')
+@KeepSymbol('ICU4XPropertyValueNameToEnumMapper_get_strict')
 @ffi.Native<
         ffi.Int16 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>, ffi.Size)>(
@@ -200,7 +200,7 @@ external int _ICU4XPropertyValueNameToEnumMapper_get_strict(
     ffi.Pointer<ffi.Uint8> nameData,
     int nameLength);
 
-@meta.ResourceIdentifier('ICU4XPropertyValueNameToEnumMapper_get_loose')
+@KeepSymbol('ICU4XPropertyValueNameToEnumMapper_get_loose')
 @ffi.Native<
         ffi.Int16 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>, ffi.Size)>(
@@ -211,8 +211,7 @@ external int _ICU4XPropertyValueNameToEnumMapper_get_loose(
     ffi.Pointer<ffi.Uint8> nameData,
     int nameLength);
 
-@meta.ResourceIdentifier(
-    'ICU4XPropertyValueNameToEnumMapper_load_general_category')
+@KeepSymbol('ICU4XPropertyValueNameToEnumMapper_load_general_category')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true,
     symbol: 'ICU4XPropertyValueNameToEnumMapper_load_general_category')
@@ -221,8 +220,7 @@ external _ResultOpaqueInt32
     _ICU4XPropertyValueNameToEnumMapper_load_general_category(
         ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier(
-    'ICU4XPropertyValueNameToEnumMapper_load_hangul_syllable_type')
+@KeepSymbol('ICU4XPropertyValueNameToEnumMapper_load_hangul_syllable_type')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true,
     symbol: 'ICU4XPropertyValueNameToEnumMapper_load_hangul_syllable_type')
@@ -231,8 +229,7 @@ external _ResultOpaqueInt32
     _ICU4XPropertyValueNameToEnumMapper_load_hangul_syllable_type(
         ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier(
-    'ICU4XPropertyValueNameToEnumMapper_load_east_asian_width')
+@KeepSymbol('ICU4XPropertyValueNameToEnumMapper_load_east_asian_width')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true,
     symbol: 'ICU4XPropertyValueNameToEnumMapper_load_east_asian_width')
@@ -241,15 +238,14 @@ external _ResultOpaqueInt32
     _ICU4XPropertyValueNameToEnumMapper_load_east_asian_width(
         ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XPropertyValueNameToEnumMapper_load_bidi_class')
+@KeepSymbol('ICU4XPropertyValueNameToEnumMapper_load_bidi_class')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XPropertyValueNameToEnumMapper_load_bidi_class')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XPropertyValueNameToEnumMapper_load_bidi_class(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier(
-    'ICU4XPropertyValueNameToEnumMapper_load_indic_syllabic_category')
+@KeepSymbol('ICU4XPropertyValueNameToEnumMapper_load_indic_syllabic_category')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true,
     symbol: 'ICU4XPropertyValueNameToEnumMapper_load_indic_syllabic_category')
@@ -258,15 +254,14 @@ external _ResultOpaqueInt32
     _ICU4XPropertyValueNameToEnumMapper_load_indic_syllabic_category(
         ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XPropertyValueNameToEnumMapper_load_line_break')
+@KeepSymbol('ICU4XPropertyValueNameToEnumMapper_load_line_break')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XPropertyValueNameToEnumMapper_load_line_break')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XPropertyValueNameToEnumMapper_load_line_break(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier(
-    'ICU4XPropertyValueNameToEnumMapper_load_grapheme_cluster_break')
+@KeepSymbol('ICU4XPropertyValueNameToEnumMapper_load_grapheme_cluster_break')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true,
     symbol: 'ICU4XPropertyValueNameToEnumMapper_load_grapheme_cluster_break')
@@ -275,15 +270,14 @@ external _ResultOpaqueInt32
     _ICU4XPropertyValueNameToEnumMapper_load_grapheme_cluster_break(
         ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XPropertyValueNameToEnumMapper_load_word_break')
+@KeepSymbol('ICU4XPropertyValueNameToEnumMapper_load_word_break')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XPropertyValueNameToEnumMapper_load_word_break')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XPropertyValueNameToEnumMapper_load_word_break(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier(
-    'ICU4XPropertyValueNameToEnumMapper_load_sentence_break')
+@KeepSymbol('ICU4XPropertyValueNameToEnumMapper_load_sentence_break')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true,
     symbol: 'ICU4XPropertyValueNameToEnumMapper_load_sentence_break')
@@ -292,7 +286,7 @@ external _ResultOpaqueInt32
     _ICU4XPropertyValueNameToEnumMapper_load_sentence_break(
         ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XPropertyValueNameToEnumMapper_load_script')
+@KeepSymbol('ICU4XPropertyValueNameToEnumMapper_load_script')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XPropertyValueNameToEnumMapper_load_script')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/RegionDisplayNames.g.dart b/pkgs/intl4x/lib/src/bindings/RegionDisplayNames.g.dart
index 56112b82..30c435a6 100644
--- a/pkgs/intl4x/lib/src/bindings/RegionDisplayNames.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/RegionDisplayNames.g.dart
@@ -57,13 +57,13 @@ final class RegionDisplayNames implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XRegionDisplayNames_destroy')
+@KeepSymbol('ICU4XRegionDisplayNames_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XRegionDisplayNames_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XRegionDisplayNames_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XRegionDisplayNames_create')
+@KeepSymbol('ICU4XRegionDisplayNames_create')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -72,7 +72,7 @@ external void _ICU4XRegionDisplayNames_destroy(ffi.Pointer<ffi.Void> self);
 external _ResultOpaqueInt32 _ICU4XRegionDisplayNames_create(
     ffi.Pointer<ffi.Opaque> provider, ffi.Pointer<ffi.Opaque> locale);
 
-@meta.ResourceIdentifier('ICU4XRegionDisplayNames_of')
+@KeepSymbol('ICU4XRegionDisplayNames_of')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Uint8>, ffi.Size, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/ReorderedIndexMap.g.dart b/pkgs/intl4x/lib/src/bindings/ReorderedIndexMap.g.dart
index 98de277f..61571f0f 100644
--- a/pkgs/intl4x/lib/src/bindings/ReorderedIndexMap.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/ReorderedIndexMap.g.dart
@@ -56,32 +56,32 @@ final class ReorderedIndexMap implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XReorderedIndexMap_destroy')
+@KeepSymbol('ICU4XReorderedIndexMap_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XReorderedIndexMap_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XReorderedIndexMap_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XReorderedIndexMap_as_slice')
+@KeepSymbol('ICU4XReorderedIndexMap_as_slice')
 @ffi.Native<_SliceUsize Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XReorderedIndexMap_as_slice')
 // ignore: non_constant_identifier_names
 external _SliceUsize _ICU4XReorderedIndexMap_as_slice(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XReorderedIndexMap_len')
+@KeepSymbol('ICU4XReorderedIndexMap_len')
 @ffi.Native<ffi.Size Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XReorderedIndexMap_len')
 // ignore: non_constant_identifier_names
 external int _ICU4XReorderedIndexMap_len(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XReorderedIndexMap_is_empty')
+@KeepSymbol('ICU4XReorderedIndexMap_is_empty')
 @ffi.Native<ffi.Bool Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XReorderedIndexMap_is_empty')
 // ignore: non_constant_identifier_names
 external bool _ICU4XReorderedIndexMap_is_empty(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XReorderedIndexMap_get')
+@KeepSymbol('ICU4XReorderedIndexMap_get')
 @ffi.Native<ffi.Size Function(ffi.Pointer<ffi.Opaque>, ffi.Size)>(
     isLeaf: true, symbol: 'ICU4XReorderedIndexMap_get')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/ScriptExtensionsSet.g.dart b/pkgs/intl4x/lib/src/bindings/ScriptExtensionsSet.g.dart
index 2324f088..09e65d2e 100644
--- a/pkgs/intl4x/lib/src/bindings/ScriptExtensionsSet.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/ScriptExtensionsSet.g.dart
@@ -55,26 +55,26 @@ final class ScriptExtensionsSet implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XScriptExtensionsSet_destroy')
+@KeepSymbol('ICU4XScriptExtensionsSet_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XScriptExtensionsSet_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XScriptExtensionsSet_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XScriptExtensionsSet_contains')
+@KeepSymbol('ICU4XScriptExtensionsSet_contains')
 @ffi.Native<ffi.Bool Function(ffi.Pointer<ffi.Opaque>, ffi.Uint16)>(
     isLeaf: true, symbol: 'ICU4XScriptExtensionsSet_contains')
 // ignore: non_constant_identifier_names
 external bool _ICU4XScriptExtensionsSet_contains(
     ffi.Pointer<ffi.Opaque> self, int script);
 
-@meta.ResourceIdentifier('ICU4XScriptExtensionsSet_count')
+@KeepSymbol('ICU4XScriptExtensionsSet_count')
 @ffi.Native<ffi.Size Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XScriptExtensionsSet_count')
 // ignore: non_constant_identifier_names
 external int _ICU4XScriptExtensionsSet_count(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XScriptExtensionsSet_script_at')
+@KeepSymbol('ICU4XScriptExtensionsSet_script_at')
 @ffi.Native<_ResultUint16Void Function(ffi.Pointer<ffi.Opaque>, ffi.Size)>(
     isLeaf: true, symbol: 'ICU4XScriptExtensionsSet_script_at')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/ScriptWithExtensions.g.dart b/pkgs/intl4x/lib/src/bindings/ScriptWithExtensions.g.dart
index 16897afe..900e7c12 100644
--- a/pkgs/intl4x/lib/src/bindings/ScriptWithExtensions.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/ScriptWithExtensions.g.dart
@@ -75,41 +75,41 @@ final class ScriptWithExtensions implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XScriptWithExtensions_destroy')
+@KeepSymbol('ICU4XScriptWithExtensions_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XScriptWithExtensions_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XScriptWithExtensions_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XScriptWithExtensions_create')
+@KeepSymbol('ICU4XScriptWithExtensions_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XScriptWithExtensions_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XScriptWithExtensions_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XScriptWithExtensions_get_script_val')
+@KeepSymbol('ICU4XScriptWithExtensions_get_script_val')
 @ffi.Native<ffi.Uint16 Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XScriptWithExtensions_get_script_val')
 // ignore: non_constant_identifier_names
 external int _ICU4XScriptWithExtensions_get_script_val(
     ffi.Pointer<ffi.Opaque> self, int codePoint);
 
-@meta.ResourceIdentifier('ICU4XScriptWithExtensions_has_script')
+@KeepSymbol('ICU4XScriptWithExtensions_has_script')
 @ffi.Native<ffi.Bool Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32, ffi.Uint16)>(
     isLeaf: true, symbol: 'ICU4XScriptWithExtensions_has_script')
 // ignore: non_constant_identifier_names
 external bool _ICU4XScriptWithExtensions_has_script(
     ffi.Pointer<ffi.Opaque> self, int codePoint, int script);
 
-@meta.ResourceIdentifier('ICU4XScriptWithExtensions_as_borrowed')
+@KeepSymbol('ICU4XScriptWithExtensions_as_borrowed')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XScriptWithExtensions_as_borrowed')
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _ICU4XScriptWithExtensions_as_borrowed(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XScriptWithExtensions_iter_ranges_for_script')
+@KeepSymbol('ICU4XScriptWithExtensions_iter_ranges_for_script')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>, ffi.Uint16)>(
     isLeaf: true, symbol: 'ICU4XScriptWithExtensions_iter_ranges_for_script')
diff --git a/pkgs/intl4x/lib/src/bindings/ScriptWithExtensionsBorrowed.g.dart b/pkgs/intl4x/lib/src/bindings/ScriptWithExtensionsBorrowed.g.dart
index ce206b6c..b8bc533b 100644
--- a/pkgs/intl4x/lib/src/bindings/ScriptWithExtensionsBorrowed.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/ScriptWithExtensionsBorrowed.g.dart
@@ -68,22 +68,21 @@ final class ScriptWithExtensionsBorrowed implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XScriptWithExtensionsBorrowed_destroy')
+@KeepSymbol('ICU4XScriptWithExtensionsBorrowed_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XScriptWithExtensionsBorrowed_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XScriptWithExtensionsBorrowed_destroy(
     ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XScriptWithExtensionsBorrowed_get_script_val')
+@KeepSymbol('ICU4XScriptWithExtensionsBorrowed_get_script_val')
 @ffi.Native<ffi.Uint16 Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XScriptWithExtensionsBorrowed_get_script_val')
 // ignore: non_constant_identifier_names
 external int _ICU4XScriptWithExtensionsBorrowed_get_script_val(
     ffi.Pointer<ffi.Opaque> self, int codePoint);
 
-@meta.ResourceIdentifier(
-    'ICU4XScriptWithExtensionsBorrowed_get_script_extensions_val')
+@KeepSymbol('ICU4XScriptWithExtensionsBorrowed_get_script_extensions_val')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true,
@@ -93,15 +92,14 @@ external ffi.Pointer<ffi.Opaque>
     _ICU4XScriptWithExtensionsBorrowed_get_script_extensions_val(
         ffi.Pointer<ffi.Opaque> self, int codePoint);
 
-@meta.ResourceIdentifier('ICU4XScriptWithExtensionsBorrowed_has_script')
+@KeepSymbol('ICU4XScriptWithExtensionsBorrowed_has_script')
 @ffi.Native<ffi.Bool Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32, ffi.Uint16)>(
     isLeaf: true, symbol: 'ICU4XScriptWithExtensionsBorrowed_has_script')
 // ignore: non_constant_identifier_names
 external bool _ICU4XScriptWithExtensionsBorrowed_has_script(
     ffi.Pointer<ffi.Opaque> self, int codePoint, int script);
 
-@meta.ResourceIdentifier(
-    'ICU4XScriptWithExtensionsBorrowed_get_script_extensions_set')
+@KeepSymbol('ICU4XScriptWithExtensionsBorrowed_get_script_extensions_set')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>, ffi.Uint16)>(
     isLeaf: true,
diff --git a/pkgs/intl4x/lib/src/bindings/SegmenterWordType.g.dart b/pkgs/intl4x/lib/src/bindings/SegmenterWordType.g.dart
index 7237dc02..174df304 100644
--- a/pkgs/intl4x/lib/src/bindings/SegmenterWordType.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/SegmenterWordType.g.dart
@@ -17,7 +17,7 @@ enum SegmenterWordType {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XSegmenterWordType_is_word_like')
+@KeepSymbol('ICU4XSegmenterWordType_is_word_like')
 @ffi.Native<ffi.Bool Function(ffi.Int32)>(
     isLeaf: true, symbol: 'ICU4XSegmenterWordType_is_word_like')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/SentenceBreakIteratorLatin1.g.dart b/pkgs/intl4x/lib/src/bindings/SentenceBreakIteratorLatin1.g.dart
index 8ccdaf5f..d15e5420 100644
--- a/pkgs/intl4x/lib/src/bindings/SentenceBreakIteratorLatin1.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/SentenceBreakIteratorLatin1.g.dart
@@ -35,14 +35,14 @@ final class SentenceBreakIteratorLatin1 implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XSentenceBreakIteratorLatin1_destroy')
+@KeepSymbol('ICU4XSentenceBreakIteratorLatin1_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XSentenceBreakIteratorLatin1_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XSentenceBreakIteratorLatin1_destroy(
     ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XSentenceBreakIteratorLatin1_next')
+@KeepSymbol('ICU4XSentenceBreakIteratorLatin1_next')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XSentenceBreakIteratorLatin1_next')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/SentenceBreakIteratorUtf16.g.dart b/pkgs/intl4x/lib/src/bindings/SentenceBreakIteratorUtf16.g.dart
index 17a807db..5a78e0aa 100644
--- a/pkgs/intl4x/lib/src/bindings/SentenceBreakIteratorUtf16.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/SentenceBreakIteratorUtf16.g.dart
@@ -35,14 +35,14 @@ final class SentenceBreakIteratorUtf16 implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XSentenceBreakIteratorUtf16_destroy')
+@KeepSymbol('ICU4XSentenceBreakIteratorUtf16_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XSentenceBreakIteratorUtf16_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XSentenceBreakIteratorUtf16_destroy(
     ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XSentenceBreakIteratorUtf16_next')
+@KeepSymbol('ICU4XSentenceBreakIteratorUtf16_next')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XSentenceBreakIteratorUtf16_next')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/SentenceBreakIteratorUtf8.g.dart b/pkgs/intl4x/lib/src/bindings/SentenceBreakIteratorUtf8.g.dart
index 684ffbfc..e433e567 100644
--- a/pkgs/intl4x/lib/src/bindings/SentenceBreakIteratorUtf8.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/SentenceBreakIteratorUtf8.g.dart
@@ -35,14 +35,14 @@ final class SentenceBreakIteratorUtf8 implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XSentenceBreakIteratorUtf8_destroy')
+@KeepSymbol('ICU4XSentenceBreakIteratorUtf8_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XSentenceBreakIteratorUtf8_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XSentenceBreakIteratorUtf8_destroy(
     ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XSentenceBreakIteratorUtf8_next')
+@KeepSymbol('ICU4XSentenceBreakIteratorUtf8_next')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XSentenceBreakIteratorUtf8_next')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/SentenceSegmenter.g.dart b/pkgs/intl4x/lib/src/bindings/SentenceSegmenter.g.dart
index c29962e2..6dd316ea 100644
--- a/pkgs/intl4x/lib/src/bindings/SentenceSegmenter.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/SentenceSegmenter.g.dart
@@ -55,20 +55,20 @@ final class SentenceSegmenter implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XSentenceSegmenter_destroy')
+@KeepSymbol('ICU4XSentenceSegmenter_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XSentenceSegmenter_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XSentenceSegmenter_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XSentenceSegmenter_create')
+@KeepSymbol('ICU4XSentenceSegmenter_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XSentenceSegmenter_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XSentenceSegmenter_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XSentenceSegmenter_segment_utf16')
+@KeepSymbol('ICU4XSentenceSegmenter_segment_utf16')
 @ffi.Native<
     ffi.Pointer<ffi.Opaque> Function(
         ffi.Pointer<ffi.Opaque>,
diff --git a/pkgs/intl4x/lib/src/bindings/Time.g.dart b/pkgs/intl4x/lib/src/bindings/Time.g.dart
index 5b569625..f850ff20 100644
--- a/pkgs/intl4x/lib/src/bindings/Time.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/Time.g.dart
@@ -84,13 +84,13 @@ final class Time implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XTime_destroy')
+@KeepSymbol('ICU4XTime_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XTime_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XTime_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XTime_create')
+@KeepSymbol('ICU4XTime_create')
 @ffi.Native<
     _ResultOpaqueInt32 Function(ffi.Uint8, ffi.Uint8, ffi.Uint8,
         ffi.Uint32)>(isLeaf: true, symbol: 'ICU4XTime_create')
@@ -98,31 +98,31 @@ external void _ICU4XTime_destroy(ffi.Pointer<ffi.Void> self);
 external _ResultOpaqueInt32 _ICU4XTime_create(
     int hour, int minute, int second, int nanosecond);
 
-@meta.ResourceIdentifier('ICU4XTime_create_midnight')
+@KeepSymbol('ICU4XTime_create_midnight')
 @ffi.Native<_ResultOpaqueInt32 Function()>(
     isLeaf: true, symbol: 'ICU4XTime_create_midnight')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XTime_create_midnight();
 
-@meta.ResourceIdentifier('ICU4XTime_hour')
+@KeepSymbol('ICU4XTime_hour')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XTime_hour')
 // ignore: non_constant_identifier_names
 external int _ICU4XTime_hour(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XTime_minute')
+@KeepSymbol('ICU4XTime_minute')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XTime_minute')
 // ignore: non_constant_identifier_names
 external int _ICU4XTime_minute(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XTime_second')
+@KeepSymbol('ICU4XTime_second')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XTime_second')
 // ignore: non_constant_identifier_names
 external int _ICU4XTime_second(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XTime_nanosecond')
+@KeepSymbol('ICU4XTime_nanosecond')
 @ffi.Native<ffi.Uint32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XTime_nanosecond')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/TimeFormatter.g.dart b/pkgs/intl4x/lib/src/bindings/TimeFormatter.g.dart
index f65dc920..a1590ac0 100644
--- a/pkgs/intl4x/lib/src/bindings/TimeFormatter.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/TimeFormatter.g.dart
@@ -86,13 +86,13 @@ final class TimeFormatter implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XTimeFormatter_destroy')
+@KeepSymbol('ICU4XTimeFormatter_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XTimeFormatter_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XTimeFormatter_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XTimeFormatter_create_with_length')
+@KeepSymbol('ICU4XTimeFormatter_create_with_length')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>, ffi.Int32)>(
@@ -103,7 +103,7 @@ external _ResultOpaqueInt32 _ICU4XTimeFormatter_create_with_length(
     ffi.Pointer<ffi.Opaque> locale,
     int length);
 
-@meta.ResourceIdentifier('ICU4XTimeFormatter_format_time')
+@KeepSymbol('ICU4XTimeFormatter_format_time')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -114,7 +114,7 @@ external _ResultVoidInt32 _ICU4XTimeFormatter_format_time(
     ffi.Pointer<ffi.Opaque> value,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XTimeFormatter_format_datetime')
+@KeepSymbol('ICU4XTimeFormatter_format_datetime')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -125,7 +125,7 @@ external _ResultVoidInt32 _ICU4XTimeFormatter_format_datetime(
     ffi.Pointer<ffi.Opaque> value,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XTimeFormatter_format_iso_datetime')
+@KeepSymbol('ICU4XTimeFormatter_format_iso_datetime')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/TimeZoneFormatter.g.dart b/pkgs/intl4x/lib/src/bindings/TimeZoneFormatter.g.dart
index a9314728..cccb3d1d 100644
--- a/pkgs/intl4x/lib/src/bindings/TimeZoneFormatter.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/TimeZoneFormatter.g.dart
@@ -190,14 +190,13 @@ final class TimeZoneFormatter implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XTimeZoneFormatter_destroy')
+@KeepSymbol('ICU4XTimeZoneFormatter_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XTimeZoneFormatter_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XTimeZoneFormatter_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier(
-    'ICU4XTimeZoneFormatter_create_with_localized_gmt_fallback')
+@KeepSymbol('ICU4XTimeZoneFormatter_create_with_localized_gmt_fallback')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -208,7 +207,7 @@ external _ResultOpaqueInt32
     _ICU4XTimeZoneFormatter_create_with_localized_gmt_fallback(
         ffi.Pointer<ffi.Opaque> provider, ffi.Pointer<ffi.Opaque> locale);
 
-@meta.ResourceIdentifier('ICU4XTimeZoneFormatter_create_with_iso_8601_fallback')
+@KeepSymbol('ICU4XTimeZoneFormatter_create_with_iso_8601_fallback')
 @ffi.Native<
         _ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, _IsoTimeZoneOptionsFfi)>(
@@ -221,8 +220,7 @@ external _ResultOpaqueInt32
         ffi.Pointer<ffi.Opaque> locale,
         _IsoTimeZoneOptionsFfi options);
 
-@meta
-    .ResourceIdentifier('ICU4XTimeZoneFormatter_load_generic_non_location_long')
+@KeepSymbol('ICU4XTimeZoneFormatter_load_generic_non_location_long')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -233,8 +231,7 @@ external _ResultVoidInt32
     _ICU4XTimeZoneFormatter_load_generic_non_location_long(
         ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier(
-    'ICU4XTimeZoneFormatter_load_generic_non_location_short')
+@KeepSymbol('ICU4XTimeZoneFormatter_load_generic_non_location_short')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -245,8 +242,7 @@ external _ResultVoidInt32
     _ICU4XTimeZoneFormatter_load_generic_non_location_short(
         ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier(
-    'ICU4XTimeZoneFormatter_load_specific_non_location_long')
+@KeepSymbol('ICU4XTimeZoneFormatter_load_specific_non_location_long')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -257,8 +253,7 @@ external _ResultVoidInt32
     _ICU4XTimeZoneFormatter_load_specific_non_location_long(
         ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier(
-    'ICU4XTimeZoneFormatter_load_specific_non_location_short')
+@KeepSymbol('ICU4XTimeZoneFormatter_load_specific_non_location_short')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -269,7 +264,7 @@ external _ResultVoidInt32
     _ICU4XTimeZoneFormatter_load_specific_non_location_short(
         ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XTimeZoneFormatter_load_generic_location_format')
+@KeepSymbol('ICU4XTimeZoneFormatter_load_generic_location_format')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -278,14 +273,14 @@ external _ResultVoidInt32
 external _ResultVoidInt32 _ICU4XTimeZoneFormatter_load_generic_location_format(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XTimeZoneFormatter_include_localized_gmt_format')
+@KeepSymbol('ICU4XTimeZoneFormatter_include_localized_gmt_format')
 @ffi.Native<_ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XTimeZoneFormatter_include_localized_gmt_format')
 // ignore: non_constant_identifier_names
 external _ResultVoidInt32 _ICU4XTimeZoneFormatter_include_localized_gmt_format(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XTimeZoneFormatter_load_iso_8601_format')
+@KeepSymbol('ICU4XTimeZoneFormatter_load_iso_8601_format')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>, _IsoTimeZoneOptionsFfi)>(
@@ -294,7 +289,7 @@ external _ResultVoidInt32 _ICU4XTimeZoneFormatter_include_localized_gmt_format(
 external _ResultVoidInt32 _ICU4XTimeZoneFormatter_load_iso_8601_format(
     ffi.Pointer<ffi.Opaque> self, _IsoTimeZoneOptionsFfi options);
 
-@meta.ResourceIdentifier('ICU4XTimeZoneFormatter_format_custom_time_zone')
+@KeepSymbol('ICU4XTimeZoneFormatter_format_custom_time_zone')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -305,8 +300,7 @@ external _ResultVoidInt32 _ICU4XTimeZoneFormatter_format_custom_time_zone(
     ffi.Pointer<ffi.Opaque> value,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier(
-    'ICU4XTimeZoneFormatter_format_custom_time_zone_no_fallback')
+@KeepSymbol('ICU4XTimeZoneFormatter_format_custom_time_zone_no_fallback')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/TimeZoneIdMapper.g.dart b/pkgs/intl4x/lib/src/bindings/TimeZoneIdMapper.g.dart
index 9c9eb3e6..1f75ebef 100644
--- a/pkgs/intl4x/lib/src/bindings/TimeZoneIdMapper.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/TimeZoneIdMapper.g.dart
@@ -104,20 +104,20 @@ final class TimeZoneIdMapper implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XTimeZoneIdMapper_destroy')
+@KeepSymbol('ICU4XTimeZoneIdMapper_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XTimeZoneIdMapper_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XTimeZoneIdMapper_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XTimeZoneIdMapper_create')
+@KeepSymbol('ICU4XTimeZoneIdMapper_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XTimeZoneIdMapper_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XTimeZoneIdMapper_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XTimeZoneIdMapper_iana_to_bcp47')
+@KeepSymbol('ICU4XTimeZoneIdMapper_iana_to_bcp47')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Uint8>, ffi.Size, ffi.Pointer<ffi.Opaque>)>(
@@ -129,7 +129,7 @@ external _ResultVoidInt32 _ICU4XTimeZoneIdMapper_iana_to_bcp47(
     int valueLength,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XTimeZoneIdMapper_normalize_iana')
+@KeepSymbol('ICU4XTimeZoneIdMapper_normalize_iana')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Uint8>, ffi.Size, ffi.Pointer<ffi.Opaque>)>(
@@ -141,7 +141,7 @@ external _ResultVoidInt32 _ICU4XTimeZoneIdMapper_normalize_iana(
     int valueLength,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XTimeZoneIdMapper_canonicalize_iana')
+@KeepSymbol('ICU4XTimeZoneIdMapper_canonicalize_iana')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Uint8>, ffi.Size, ffi.Pointer<ffi.Opaque>)>(
@@ -153,7 +153,7 @@ external _ResultVoidInt32 _ICU4XTimeZoneIdMapper_canonicalize_iana(
     int valueLength,
     ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier('ICU4XTimeZoneIdMapper_find_canonical_iana_from_bcp47')
+@KeepSymbol('ICU4XTimeZoneIdMapper_find_canonical_iana_from_bcp47')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Uint8>, ffi.Size, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/TimeZoneIdMapperWithFastCanonicalization.g.dart b/pkgs/intl4x/lib/src/bindings/TimeZoneIdMapperWithFastCanonicalization.g.dart
index 705286b9..4b1a8608 100644
--- a/pkgs/intl4x/lib/src/bindings/TimeZoneIdMapperWithFastCanonicalization.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/TimeZoneIdMapperWithFastCanonicalization.g.dart
@@ -77,8 +77,7 @@ final class TimeZoneIdMapperWithFastCanonicalization
   }
 }
 
-@meta
-    .ResourceIdentifier('ICU4XTimeZoneIdMapperWithFastCanonicalization_destroy')
+@KeepSymbol('ICU4XTimeZoneIdMapperWithFastCanonicalization_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true,
     symbol: 'ICU4XTimeZoneIdMapperWithFastCanonicalization_destroy')
@@ -86,7 +85,7 @@ final class TimeZoneIdMapperWithFastCanonicalization
 external void _ICU4XTimeZoneIdMapperWithFastCanonicalization_destroy(
     ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XTimeZoneIdMapperWithFastCanonicalization_create')
+@KeepSymbol('ICU4XTimeZoneIdMapperWithFastCanonicalization_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true,
     symbol: 'ICU4XTimeZoneIdMapperWithFastCanonicalization_create')
@@ -95,8 +94,7 @@ external _ResultOpaqueInt32
     _ICU4XTimeZoneIdMapperWithFastCanonicalization_create(
         ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier(
-    'ICU4XTimeZoneIdMapperWithFastCanonicalization_canonicalize_iana')
+@KeepSymbol('ICU4XTimeZoneIdMapperWithFastCanonicalization_canonicalize_iana')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Uint8>, ffi.Size, ffi.Pointer<ffi.Opaque>)>(
@@ -110,7 +108,7 @@ external _ResultVoidInt32
         int valueLength,
         ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier(
+@KeepSymbol(
     'ICU4XTimeZoneIdMapperWithFastCanonicalization_canonical_iana_from_bcp47')
 @ffi.Native<
         _ResultVoidInt32 Function(ffi.Pointer<ffi.Opaque>,
diff --git a/pkgs/intl4x/lib/src/bindings/TitlecaseMapper.g.dart b/pkgs/intl4x/lib/src/bindings/TitlecaseMapper.g.dart
index 8aa3d365..93f2238f 100644
--- a/pkgs/intl4x/lib/src/bindings/TitlecaseMapper.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/TitlecaseMapper.g.dart
@@ -62,20 +62,20 @@ final class TitlecaseMapper implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XTitlecaseMapper_destroy')
+@KeepSymbol('ICU4XTitlecaseMapper_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XTitlecaseMapper_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XTitlecaseMapper_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XTitlecaseMapper_create')
+@KeepSymbol('ICU4XTitlecaseMapper_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XTitlecaseMapper_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XTitlecaseMapper_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XTitlecaseMapper_titlecase_segment_v1')
+@KeepSymbol('ICU4XTitlecaseMapper_titlecase_segment_v1')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>,
diff --git a/pkgs/intl4x/lib/src/bindings/TitlecaseOptions.g.dart b/pkgs/intl4x/lib/src/bindings/TitlecaseOptions.g.dart
index ce16b2bb..733d4af7 100644
--- a/pkgs/intl4x/lib/src/bindings/TitlecaseOptions.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/TitlecaseOptions.g.dart
@@ -59,7 +59,7 @@ final class TitlecaseOptions {
       ]);
 }
 
-@meta.ResourceIdentifier('ICU4XTitlecaseOptionsV1_default_options')
+@KeepSymbol('ICU4XTitlecaseOptionsV1_default_options')
 @ffi.Native<_TitlecaseOptionsFfi Function()>(
     isLeaf: true, symbol: 'ICU4XTitlecaseOptionsV1_default_options')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/UnicodeSetData.g.dart b/pkgs/intl4x/lib/src/bindings/UnicodeSetData.g.dart
index 3b27151f..27415513 100644
--- a/pkgs/intl4x/lib/src/bindings/UnicodeSetData.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/UnicodeSetData.g.dart
@@ -124,13 +124,13 @@ final class UnicodeSetData implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XUnicodeSetData_destroy')
+@KeepSymbol('ICU4XUnicodeSetData_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XUnicodeSetData_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XUnicodeSetData_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XUnicodeSetData_contains')
+@KeepSymbol('ICU4XUnicodeSetData_contains')
 @ffi.Native<
     ffi.Bool Function(ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Uint8>,
         ffi.Size)>(isLeaf: true, symbol: 'ICU4XUnicodeSetData_contains')
@@ -138,21 +138,21 @@ external void _ICU4XUnicodeSetData_destroy(ffi.Pointer<ffi.Void> self);
 external bool _ICU4XUnicodeSetData_contains(
     ffi.Pointer<ffi.Opaque> self, ffi.Pointer<ffi.Uint8> sData, int sLength);
 
-@meta.ResourceIdentifier('ICU4XUnicodeSetData_contains_char')
+@KeepSymbol('ICU4XUnicodeSetData_contains_char')
 @ffi.Native<ffi.Bool Function(ffi.Pointer<ffi.Opaque>, ffi.Uint32)>(
     isLeaf: true, symbol: 'ICU4XUnicodeSetData_contains_char')
 // ignore: non_constant_identifier_names
 external bool _ICU4XUnicodeSetData_contains_char(
     ffi.Pointer<ffi.Opaque> self, Rune cp);
 
-@meta.ResourceIdentifier('ICU4XUnicodeSetData_load_basic_emoji')
+@KeepSymbol('ICU4XUnicodeSetData_load_basic_emoji')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XUnicodeSetData_load_basic_emoji')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XUnicodeSetData_load_basic_emoji(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XUnicodeSetData_load_exemplars_main')
+@KeepSymbol('ICU4XUnicodeSetData_load_exemplars_main')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -161,7 +161,7 @@ external _ResultOpaqueInt32 _ICU4XUnicodeSetData_load_basic_emoji(
 external _ResultOpaqueInt32 _ICU4XUnicodeSetData_load_exemplars_main(
     ffi.Pointer<ffi.Opaque> provider, ffi.Pointer<ffi.Opaque> locale);
 
-@meta.ResourceIdentifier('ICU4XUnicodeSetData_load_exemplars_auxiliary')
+@KeepSymbol('ICU4XUnicodeSetData_load_exemplars_auxiliary')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -170,7 +170,7 @@ external _ResultOpaqueInt32 _ICU4XUnicodeSetData_load_exemplars_main(
 external _ResultOpaqueInt32 _ICU4XUnicodeSetData_load_exemplars_auxiliary(
     ffi.Pointer<ffi.Opaque> provider, ffi.Pointer<ffi.Opaque> locale);
 
-@meta.ResourceIdentifier('ICU4XUnicodeSetData_load_exemplars_punctuation')
+@KeepSymbol('ICU4XUnicodeSetData_load_exemplars_punctuation')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -179,7 +179,7 @@ external _ResultOpaqueInt32 _ICU4XUnicodeSetData_load_exemplars_auxiliary(
 external _ResultOpaqueInt32 _ICU4XUnicodeSetData_load_exemplars_punctuation(
     ffi.Pointer<ffi.Opaque> provider, ffi.Pointer<ffi.Opaque> locale);
 
-@meta.ResourceIdentifier('ICU4XUnicodeSetData_load_exemplars_numbers')
+@KeepSymbol('ICU4XUnicodeSetData_load_exemplars_numbers')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -188,7 +188,7 @@ external _ResultOpaqueInt32 _ICU4XUnicodeSetData_load_exemplars_punctuation(
 external _ResultOpaqueInt32 _ICU4XUnicodeSetData_load_exemplars_numbers(
     ffi.Pointer<ffi.Opaque> provider, ffi.Pointer<ffi.Opaque> locale);
 
-@meta.ResourceIdentifier('ICU4XUnicodeSetData_load_exemplars_index')
+@KeepSymbol('ICU4XUnicodeSetData_load_exemplars_index')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
diff --git a/pkgs/intl4x/lib/src/bindings/UnitsConverter.g.dart b/pkgs/intl4x/lib/src/bindings/UnitsConverter.g.dart
index 63abfb79..89d42963 100644
--- a/pkgs/intl4x/lib/src/bindings/UnitsConverter.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/UnitsConverter.g.dart
@@ -46,20 +46,20 @@ final class UnitsConverter implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XUnitsConverter_destroy')
+@KeepSymbol('ICU4XUnitsConverter_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XUnitsConverter_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XUnitsConverter_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XUnitsConverter_convert_f64')
+@KeepSymbol('ICU4XUnitsConverter_convert_f64')
 @ffi.Native<ffi.Double Function(ffi.Pointer<ffi.Opaque>, ffi.Double)>(
     isLeaf: true, symbol: 'ICU4XUnitsConverter_convert_f64')
 // ignore: non_constant_identifier_names
 external double _ICU4XUnitsConverter_convert_f64(
     ffi.Pointer<ffi.Opaque> self, double value);
 
-@meta.ResourceIdentifier('ICU4XUnitsConverter_clone')
+@KeepSymbol('ICU4XUnitsConverter_clone')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XUnitsConverter_clone')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/UnitsConverterFactory.g.dart b/pkgs/intl4x/lib/src/bindings/UnitsConverterFactory.g.dart
index 85c1e96b..e34d3841 100644
--- a/pkgs/intl4x/lib/src/bindings/UnitsConverterFactory.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/UnitsConverterFactory.g.dart
@@ -62,20 +62,20 @@ final class UnitsConverterFactory implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XUnitsConverterFactory_destroy')
+@KeepSymbol('ICU4XUnitsConverterFactory_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XUnitsConverterFactory_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XUnitsConverterFactory_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XUnitsConverterFactory_create')
+@KeepSymbol('ICU4XUnitsConverterFactory_create')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XUnitsConverterFactory_create')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XUnitsConverterFactory_create(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XUnitsConverterFactory_converter')
+@KeepSymbol('ICU4XUnitsConverterFactory_converter')
 @ffi.Native<
         ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -86,7 +86,7 @@ external ffi.Pointer<ffi.Opaque> _ICU4XUnitsConverterFactory_converter(
     ffi.Pointer<ffi.Opaque> from,
     ffi.Pointer<ffi.Opaque> to);
 
-@meta.ResourceIdentifier('ICU4XUnitsConverterFactory_parser')
+@KeepSymbol('ICU4XUnitsConverterFactory_parser')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XUnitsConverterFactory_parser')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/WeekCalculator.g.dart b/pkgs/intl4x/lib/src/bindings/WeekCalculator.g.dart
index 7c1f2f12..436e59cd 100644
--- a/pkgs/intl4x/lib/src/bindings/WeekCalculator.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/WeekCalculator.g.dart
@@ -71,13 +71,13 @@ final class WeekCalculator implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XWeekCalculator_destroy')
+@KeepSymbol('ICU4XWeekCalculator_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XWeekCalculator_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XWeekCalculator_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XWeekCalculator_create')
+@KeepSymbol('ICU4XWeekCalculator_create')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
             ffi.Pointer<ffi.Opaque>, ffi.Pointer<ffi.Opaque>)>(
@@ -86,7 +86,7 @@ external void _ICU4XWeekCalculator_destroy(ffi.Pointer<ffi.Void> self);
 external _ResultOpaqueInt32 _ICU4XWeekCalculator_create(
     ffi.Pointer<ffi.Opaque> provider, ffi.Pointer<ffi.Opaque> locale);
 
-@meta.ResourceIdentifier(
+@KeepSymbol(
     'ICU4XWeekCalculator_create_from_first_day_of_week_and_min_week_days')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Int32, ffi.Uint8)>(
     isLeaf: true,
@@ -97,19 +97,19 @@ external ffi.Pointer<ffi.Opaque>
     _ICU4XWeekCalculator_create_from_first_day_of_week_and_min_week_days(
         int firstWeekday, int minWeekDays);
 
-@meta.ResourceIdentifier('ICU4XWeekCalculator_first_weekday')
+@KeepSymbol('ICU4XWeekCalculator_first_weekday')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XWeekCalculator_first_weekday')
 // ignore: non_constant_identifier_names
 external int _ICU4XWeekCalculator_first_weekday(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XWeekCalculator_min_week_days')
+@KeepSymbol('ICU4XWeekCalculator_min_week_days')
 @ffi.Native<ffi.Uint8 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XWeekCalculator_min_week_days')
 // ignore: non_constant_identifier_names
 external int _ICU4XWeekCalculator_min_week_days(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XWeekCalculator_weekend')
+@KeepSymbol('ICU4XWeekCalculator_weekend')
 @ffi.Native<_WeekendContainsDayFfi Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XWeekCalculator_weekend')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/WordBreakIteratorLatin1.g.dart b/pkgs/intl4x/lib/src/bindings/WordBreakIteratorLatin1.g.dart
index 1c394487..0c28d142 100644
--- a/pkgs/intl4x/lib/src/bindings/WordBreakIteratorLatin1.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/WordBreakIteratorLatin1.g.dart
@@ -51,26 +51,26 @@ final class WordBreakIteratorLatin1 implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XWordBreakIteratorLatin1_destroy')
+@KeepSymbol('ICU4XWordBreakIteratorLatin1_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XWordBreakIteratorLatin1_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XWordBreakIteratorLatin1_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XWordBreakIteratorLatin1_next')
+@KeepSymbol('ICU4XWordBreakIteratorLatin1_next')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XWordBreakIteratorLatin1_next')
 // ignore: non_constant_identifier_names
 external int _ICU4XWordBreakIteratorLatin1_next(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XWordBreakIteratorLatin1_word_type')
+@KeepSymbol('ICU4XWordBreakIteratorLatin1_word_type')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XWordBreakIteratorLatin1_word_type')
 // ignore: non_constant_identifier_names
 external int _ICU4XWordBreakIteratorLatin1_word_type(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XWordBreakIteratorLatin1_is_word_like')
+@KeepSymbol('ICU4XWordBreakIteratorLatin1_is_word_like')
 @ffi.Native<ffi.Bool Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XWordBreakIteratorLatin1_is_word_like')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/WordBreakIteratorUtf16.g.dart b/pkgs/intl4x/lib/src/bindings/WordBreakIteratorUtf16.g.dart
index 37ee1d92..fdeee92f 100644
--- a/pkgs/intl4x/lib/src/bindings/WordBreakIteratorUtf16.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/WordBreakIteratorUtf16.g.dart
@@ -51,26 +51,26 @@ final class WordBreakIteratorUtf16 implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XWordBreakIteratorUtf16_destroy')
+@KeepSymbol('ICU4XWordBreakIteratorUtf16_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XWordBreakIteratorUtf16_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XWordBreakIteratorUtf16_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XWordBreakIteratorUtf16_next')
+@KeepSymbol('ICU4XWordBreakIteratorUtf16_next')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XWordBreakIteratorUtf16_next')
 // ignore: non_constant_identifier_names
 external int _ICU4XWordBreakIteratorUtf16_next(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XWordBreakIteratorUtf16_word_type')
+@KeepSymbol('ICU4XWordBreakIteratorUtf16_word_type')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XWordBreakIteratorUtf16_word_type')
 // ignore: non_constant_identifier_names
 external int _ICU4XWordBreakIteratorUtf16_word_type(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XWordBreakIteratorUtf16_is_word_like')
+@KeepSymbol('ICU4XWordBreakIteratorUtf16_is_word_like')
 @ffi.Native<ffi.Bool Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XWordBreakIteratorUtf16_is_word_like')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/WordBreakIteratorUtf8.g.dart b/pkgs/intl4x/lib/src/bindings/WordBreakIteratorUtf8.g.dart
index 8460986d..e97c5445 100644
--- a/pkgs/intl4x/lib/src/bindings/WordBreakIteratorUtf8.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/WordBreakIteratorUtf8.g.dart
@@ -51,26 +51,26 @@ final class WordBreakIteratorUtf8 implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XWordBreakIteratorUtf8_destroy')
+@KeepSymbol('ICU4XWordBreakIteratorUtf8_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XWordBreakIteratorUtf8_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XWordBreakIteratorUtf8_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XWordBreakIteratorUtf8_next')
+@KeepSymbol('ICU4XWordBreakIteratorUtf8_next')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XWordBreakIteratorUtf8_next')
 // ignore: non_constant_identifier_names
 external int _ICU4XWordBreakIteratorUtf8_next(ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XWordBreakIteratorUtf8_word_type')
+@KeepSymbol('ICU4XWordBreakIteratorUtf8_word_type')
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XWordBreakIteratorUtf8_word_type')
 // ignore: non_constant_identifier_names
 external int _ICU4XWordBreakIteratorUtf8_word_type(
     ffi.Pointer<ffi.Opaque> self);
 
-@meta.ResourceIdentifier('ICU4XWordBreakIteratorUtf8_is_word_like')
+@KeepSymbol('ICU4XWordBreakIteratorUtf8_is_word_like')
 @ffi.Native<ffi.Bool Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XWordBreakIteratorUtf8_is_word_like')
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/bindings/WordSegmenter.g.dart b/pkgs/intl4x/lib/src/bindings/WordSegmenter.g.dart
index fa104a78..6c909016 100644
--- a/pkgs/intl4x/lib/src/bindings/WordSegmenter.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/WordSegmenter.g.dart
@@ -90,34 +90,34 @@ final class WordSegmenter implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XWordSegmenter_destroy')
+@KeepSymbol('ICU4XWordSegmenter_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XWordSegmenter_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XWordSegmenter_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XWordSegmenter_create_auto')
+@KeepSymbol('ICU4XWordSegmenter_create_auto')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XWordSegmenter_create_auto')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XWordSegmenter_create_auto(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XWordSegmenter_create_lstm')
+@KeepSymbol('ICU4XWordSegmenter_create_lstm')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XWordSegmenter_create_lstm')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XWordSegmenter_create_lstm(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XWordSegmenter_create_dictionary')
+@KeepSymbol('ICU4XWordSegmenter_create_dictionary')
 @ffi.Native<_ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>)>(
     isLeaf: true, symbol: 'ICU4XWordSegmenter_create_dictionary')
 // ignore: non_constant_identifier_names
 external _ResultOpaqueInt32 _ICU4XWordSegmenter_create_dictionary(
     ffi.Pointer<ffi.Opaque> provider);
 
-@meta.ResourceIdentifier('ICU4XWordSegmenter_segment_utf16')
+@KeepSymbol('ICU4XWordSegmenter_segment_utf16')
 @ffi.Native<
     ffi.Pointer<ffi.Opaque> Function(
         ffi.Pointer<ffi.Opaque>,
diff --git a/pkgs/intl4x/lib/src/bindings/ZonedDateTimeFormatter.g.dart b/pkgs/intl4x/lib/src/bindings/ZonedDateTimeFormatter.g.dart
index a25b8fe4..f3529314 100644
--- a/pkgs/intl4x/lib/src/bindings/ZonedDateTimeFormatter.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/ZonedDateTimeFormatter.g.dart
@@ -107,13 +107,13 @@ final class ZonedDateTimeFormatter implements ffi.Finalizable {
   }
 }
 
-@meta.ResourceIdentifier('ICU4XZonedDateTimeFormatter_destroy')
+@KeepSymbol('ICU4XZonedDateTimeFormatter_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
     isLeaf: true, symbol: 'ICU4XZonedDateTimeFormatter_destroy')
 // ignore: non_constant_identifier_names
 external void _ICU4XZonedDateTimeFormatter_destroy(ffi.Pointer<ffi.Void> self);
 
-@meta.ResourceIdentifier('ICU4XZonedDateTimeFormatter_create_with_lengths')
+@KeepSymbol('ICU4XZonedDateTimeFormatter_create_with_lengths')
 @ffi.Native<
         _ResultOpaqueInt32 Function(ffi.Pointer<ffi.Opaque>,
             ffi.Pointer<ffi.Opaque>, ffi.Int32, ffi.Int32)>(
@@ -125,7 +125,7 @@ external _ResultOpaqueInt32 _ICU4XZonedDateTimeFormatter_create_with_lengths(
     int dateLength,
     int timeLength);
 
-@meta.ResourceIdentifier(
+@KeepSymbol(
     'ICU4XZonedDateTimeFormatter_create_with_lengths_and_iso_8601_time_zone_fallback')
 @ffi.Native<
         _ResultOpaqueInt32 Function(
@@ -146,8 +146,7 @@ external _ResultOpaqueInt32
         int timeLength,
         _IsoTimeZoneOptionsFfi zoneOptions);
 
-@meta.ResourceIdentifier(
-    'ICU4XZonedDateTimeFormatter_format_datetime_with_custom_time_zone')
+@KeepSymbol('ICU4XZonedDateTimeFormatter_format_datetime_with_custom_time_zone')
 @ffi.Native<
         _ResultVoidInt32 Function(
             ffi.Pointer<ffi.Opaque>,
@@ -164,7 +163,7 @@ external _ResultVoidInt32
         ffi.Pointer<ffi.Opaque> timeZone,
         ffi.Pointer<ffi.Opaque> writeable);
 
-@meta.ResourceIdentifier(
+@KeepSymbol(
     'ICU4XZonedDateTimeFormatter_format_iso_datetime_with_custom_time_zone')
 @ffi.Native<
         _ResultVoidInt32 Function(
diff --git a/pkgs/intl4x/lib/src/bindings/lib.g.dart b/pkgs/intl4x/lib/src/bindings/lib.g.dart
index cb9e50df..cd7b0847 100644
--- a/pkgs/intl4x/lib/src/bindings/lib.g.dart
+++ b/pkgs/intl4x/lib/src/bindings/lib.g.dart
@@ -137,6 +137,13 @@ part 'WordBreakIteratorUtf8.g.dart';
 part 'WordSegmenter.g.dart';
 part 'ZonedDateTimeFormatter.g.dart';
 
+@meta.RecordUse()
+class KeepSymbol {
+  final String symbol;
+
+  const KeepSymbol(this.symbol);
+}
+
 /// A [Rune] is a Unicode code point, such as `a`, or `💡`.
 ///
 /// The recommended way to obtain a [Rune] is to create it from a
@@ -175,13 +182,13 @@ final class _RustAlloc implements ffi.Allocator {
   }
 }
 
-@meta.ResourceIdentifier('diplomat_alloc')
+@KeepSymbol('diplomat_alloc')
 @ffi.Native<ffi.Pointer<ffi.Void> Function(ffi.Size, ffi.Size)>(
     symbol: 'diplomat_alloc', isLeaf: true)
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Void> _diplomat_alloc(int len, int align);
 
-@meta.ResourceIdentifier('diplomat_free')
+@KeepSymbol('diplomat_free')
 @ffi.Native<ffi.Size Function(ffi.Pointer<ffi.Void>, ffi.Size, ffi.Size)>(
     symbol: 'diplomat_free', isLeaf: true)
 // ignore: non_constant_identifier_names
@@ -767,26 +774,26 @@ final class _Writeable {
   }
 }
 
-@meta.ResourceIdentifier('diplomat_buffer_writeable_create')
+@KeepSymbol('diplomat_buffer_writeable_create')
 @ffi.Native<ffi.Pointer<ffi.Opaque> Function(ffi.Size)>(
     symbol: 'diplomat_buffer_writeable_create', isLeaf: true)
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Opaque> _diplomat_buffer_writeable_create(int len);
 
-@meta.ResourceIdentifier('diplomat_buffer_writeable_len')
+@KeepSymbol('diplomat_buffer_writeable_len')
 @ffi.Native<ffi.Size Function(ffi.Pointer<ffi.Opaque>)>(
     symbol: 'diplomat_buffer_writeable_len', isLeaf: true)
 // ignore: non_constant_identifier_names
 external int _diplomat_buffer_writeable_len(ffi.Pointer<ffi.Opaque> ptr);
 
-@meta.ResourceIdentifier('diplomat_buffer_writeable_get_bytes')
+@KeepSymbol('diplomat_buffer_writeable_get_bytes')
 @ffi.Native<ffi.Pointer<ffi.Uint8> Function(ffi.Pointer<ffi.Opaque>)>(
     symbol: 'diplomat_buffer_writeable_get_bytes', isLeaf: true)
 // ignore: non_constant_identifier_names
 external ffi.Pointer<ffi.Uint8> _diplomat_buffer_writeable_get_bytes(
     ffi.Pointer<ffi.Opaque> ptr);
 
-@meta.ResourceIdentifier('diplomat_buffer_writeable_destroy')
+@KeepSymbol('diplomat_buffer_writeable_destroy')
 @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Opaque>)>(
     symbol: 'diplomat_buffer_writeable_destroy', isLeaf: true)
 // ignore: non_constant_identifier_names
diff --git a/pkgs/intl4x/lib/src/collation/collation_impl.dart b/pkgs/intl4x/lib/src/collation/collation_impl.dart
index de22662f..c00357c9 100644
--- a/pkgs/intl4x/lib/src/collation/collation_impl.dart
+++ b/pkgs/intl4x/lib/src/collation/collation_impl.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 'package:meta/meta.dart' show ResourceIdentifier;
-
 import '../data.dart';
 import '../ecma/ecma_policy.dart';
 import '../locale/locale.dart';
@@ -25,7 +23,6 @@ abstract class CollationImpl {
 
   /// Factory to get the correct implementation, either calling on ICU4X or the
   /// in-built browser implementation.
-  @ResourceIdentifier('Collation')
   static CollationImpl build(
     Locale locale,
     Data data,
diff --git a/pkgs/intl4x/lib/src/datetime_format/datetime_format_impl.dart b/pkgs/intl4x/lib/src/datetime_format/datetime_format_impl.dart
index a84a3864..a217b3b1 100644
--- a/pkgs/intl4x/lib/src/datetime_format/datetime_format_impl.dart
+++ b/pkgs/intl4x/lib/src/datetime_format/datetime_format_impl.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 'package:meta/meta.dart' show ResourceIdentifier;
-
 import '../data.dart';
 import '../ecma/ecma_policy.dart';
 import '../locale/locale.dart';
@@ -25,7 +23,6 @@ abstract class DateTimeFormatImpl {
 
   String formatImpl(DateTime datetime);
 
-  @ResourceIdentifier('DisplayNames')
   static DateTimeFormatImpl build(
     Locale locale,
     Data data,
diff --git a/pkgs/intl4x/lib/src/display_names/display_names_impl.dart b/pkgs/intl4x/lib/src/display_names/display_names_impl.dart
index 01a0be6a..7ce43621 100644
--- a/pkgs/intl4x/lib/src/display_names/display_names_impl.dart
+++ b/pkgs/intl4x/lib/src/display_names/display_names_impl.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 'package:meta/meta.dart' show ResourceIdentifier;
-
 import '../data.dart';
 import '../ecma/ecma_policy.dart';
 import '../locale/locale.dart';
@@ -34,7 +32,6 @@ abstract class DisplayNamesImpl {
 
   String ofCalendar(Calendar calendar);
 
-  @ResourceIdentifier('DisplayNames')
   static DisplayNamesImpl build(
     Locale locale,
     Data data,
diff --git a/pkgs/intl4x/lib/src/list_format/list_format_impl.dart b/pkgs/intl4x/lib/src/list_format/list_format_impl.dart
index 00aafd48..e64a77cb 100644
--- a/pkgs/intl4x/lib/src/list_format/list_format_impl.dart
+++ b/pkgs/intl4x/lib/src/list_format/list_format_impl.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 'package:meta/meta.dart' show ResourceIdentifier;
-
 import '../../ecma_policy.dart';
 import '../data.dart';
 import '../ecma/ecma_policy.dart';
@@ -22,7 +20,6 @@ abstract class ListFormatImpl {
 
   String formatImpl(List<String> list);
 
-  @ResourceIdentifier('ListFormat')
   static ListFormatImpl build(
     Locale locales,
     Data data,
diff --git a/pkgs/intl4x/lib/src/locale/locale.dart b/pkgs/intl4x/lib/src/locale/locale.dart
index e1c5e00f..3f1d8ace 100644
--- a/pkgs/intl4x/lib/src/locale/locale.dart
+++ b/pkgs/intl4x/lib/src/locale/locale.dart
@@ -29,8 +29,6 @@ class Locale {
   final String? numberingSystem;
   final bool? numeric;
 
-  //TODO(mosum): Add ResourceIdentifier here, as soon as it is supported on
-  //const constructors
   const Locale({
     required this.language,
     this.region,
diff --git a/pkgs/intl4x/lib/src/number_format/number_format_impl.dart b/pkgs/intl4x/lib/src/number_format/number_format_impl.dart
index d82716cb..c3faa046 100644
--- a/pkgs/intl4x/lib/src/number_format/number_format_impl.dart
+++ b/pkgs/intl4x/lib/src/number_format/number_format_impl.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 'package:meta/meta.dart' show ResourceIdentifier;
-
 import '../data.dart';
 import '../ecma/ecma_policy.dart';
 import '../locale/locale.dart';
@@ -24,7 +22,6 @@ abstract class NumberFormatImpl {
 
   String formatImpl(Object number);
 
-  @ResourceIdentifier('NumberFormat')
   static NumberFormatImpl build(
     Locale locale,
     Data data,
diff --git a/pkgs/intl4x/lib/src/plural_rules/plural_rules_impl.dart b/pkgs/intl4x/lib/src/plural_rules/plural_rules_impl.dart
index 854ebe35..c6809eba 100644
--- a/pkgs/intl4x/lib/src/plural_rules/plural_rules_impl.dart
+++ b/pkgs/intl4x/lib/src/plural_rules/plural_rules_impl.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 'package:meta/meta.dart' show ResourceIdentifier;
-
 import '../../ecma_policy.dart';
 import '../data.dart';
 import '../ecma/ecma_policy.dart';
@@ -23,7 +21,6 @@ abstract class PluralRulesImpl {
 
   PluralCategory selectImpl(num number);
 
-  @ResourceIdentifier('PluralRules')
   static PluralRulesImpl build(
     Locale locales,
     Data data,
diff --git a/pkgs/intl4x/pubspec.yaml b/pkgs/intl4x/pubspec.yaml
index 6831707a..15222e5d 100644
--- a/pkgs/intl4x/pubspec.yaml
+++ b/pkgs/intl4x/pubspec.yaml
@@ -19,29 +19,18 @@ environment:
   sdk: ">=3.6.0-0 <4.0.0"
 
 dependencies:
+  collection: ^1.19.0
   crypto: ^3.0.3
   ffi: ^2.1.0
   js: ^0.7.1
   logging: ^1.2.0
-  meta: ^1.12.0
-  native_assets_cli:
-    # path: ../../../native/pkgs/native_assets_cli
-    git: 
-      url: https://github.com/dart-lang/native.git
-      path: pkgs/native_assets_cli
-      ref: fixLinkerSomeMore
-
-  native_toolchain_c:
-    # path: ../../../native/pkgs/native_toolchain_c
-    git: 
-      url: https://github.com/dart-lang/native.git
-      path: pkgs/native_toolchain_c
-      ref: fixLinkerSomeMore
-      
+  meta: ^1.16.0
+  native_assets_cli: ^0.8.0
+  native_toolchain_c: ^0.5.4
   path: ^1.9.0
+  record_use: ^0.3.0
 
 dev_dependencies:
   args: ^2.4.2
-  collection: ^1.18.0
   dart_flutter_team_lints: ^3.1.0
   test: ^1.22.1