Upgrade

Author: mosuem

pkgs/intl4x/analysis_options.yaml

@@ -12,6 +12,8 @@ analyzer:
   exclude:
     - "submodules/*"
     - "lib/src/bindings/*"
+    - lib/src/hook_helpers/build_libs.g.dart
+    - tool/build_libs.g.dart
 
   enable-experiment:
     - native-assets

pkgs/intl4x/example_native/pubspec.yaml

@@ -11,9 +11,10 @@ dependencies:
     path: ../
 
 dev_dependencies:
-  lints: ^5.0.0
+  lints: ^6.0.0
 
 hook:
   intl4x:
-    buildMode: fetch
+    buildMode: checkout
+    checkoutPath: ../../../submodules/icu4x
     treeshake: true

pkgs/intl4x/hook/build.dart

@@ -5,15 +5,13 @@
 import 'dart:io';
 
 import 'package:crypto/crypto.dart' show sha256;
-import 'package:intl4x/src/hook_helpers/build_options.dart';
-import 'package:intl4x/src/hook_helpers/hashes.dart';
-import 'package:intl4x/src/hook_helpers/shared.dart'
-    show assetId, package, runProcess;
-import 'package:intl4x/src/hook_helpers/version.dart';
+import 'package:intl4x/src/hook_helpers/build_libs.g.dart' show buildLib;
+import 'package:intl4x/src/hook_helpers/build_options.dart'
+    show BuildModeEnum, getBuildOptions;
+import 'package:intl4x/src/hook_helpers/hashes.dart' show fileHashes;
+import 'package:intl4x/src/hook_helpers/shared.dart' show assetId, package;
+import 'package:intl4x/src/hook_helpers/version.dart' show version;
 import 'package:native_assets_cli/code_assets.dart';
-import 'package:path/path.dart' as path;
-
-const crateName = 'icu_capi';
 
 void main(List<String> args) async {
   await build(args, (input, output) async {
@@ -85,7 +83,10 @@ hook:
         os: targetOS,
         file: builtLibrary,
       ),
-      linkInPackage: input.config.linkingEnabled ? package : null,
+      routing:
+          input.config.linkingEnabled
+              ? const ToLinkHook(package)
+              : const ToAppBundle(),
     );
 
     output.addDependencies(buildMode.dependencies);
@@ -198,11 +199,27 @@ final class CheckoutMode extends BuildMode {
     print('Running in `checkout` mode');
     if (checkoutPath == null) {
       throw ArgumentError(
-        'Specify the ICU4X checkout folder'
-        'with the LOCAL_ICU4X_CHECKOUT variable',
+        'Specify the ICU4X checkout folder with the `checkoutPath` key in your '
+        'pubspec build options.',
       );
     }
-    return await buildLib(input, checkoutPath!, treeshake);
+    final builtLib = await buildLib(
+      input.config.code.targetOS,
+      input.config.code.targetArchitecture,
+      input.config.buildStatic(treeshake),
+      input.config.code.targetOS == OS.iOS &&
+          input.config.code.iOS.targetSdk == IOSSdk.iPhoneSimulator,
+      Directory(checkoutPath!),
+      [
+        'icu_collator',
+        'icu_datetime',
+        'icu_list',
+        'icu_decimal',
+        'icu_plurals',
+        'experimental_components',
+      ],
+    );
+    return builtLib.uri;
   }
 
   @override
@@ -211,127 +228,6 @@ final class CheckoutMode extends BuildMode {
   ];
 }
 
-//TODO: Reuse code from package:icu4x as soon as it is published.
-Future<Uri> buildLib(
-  BuildInput input,
-  String workingDirectory,
-  bool treeshake,
-) async {
-  final crateNameFixed = crateName.replaceAll('-', '_');
-  final libFileName = input.config.filename(treeshake)(crateNameFixed);
-  final libFileUri = input.outputDirectory.resolve(libFileName);
-
-  final code = input.config.code;
-  final targetOS = code.targetOS;
-  final targetArchitecture = code.targetArchitecture;
-  final buildStatic = input.config.buildStatic(treeshake);
-
-  final isNoStd = _isNoStdTarget((targetOS, targetArchitecture));
-  final target = asRustTarget(input);
-
-  if (!isNoStd) {
-    final rustArguments = ['target', 'add', target];
-    await runProcess(
-      'rustup',
-      rustArguments,
-      workingDirectory: workingDirectory,
-    );
-  }
-  final stdFeatures = ['logging', 'simple_logger'];
-  final noStdFeatures = ['libc_alloc', 'panic_handler'];
-  final features = {
-    'default_components',
-    'icu_collator',
-    'icu_datetime',
-    'icu_list',
-    'icu_decimal',
-    'icu_plurals',
-    'compiled_data',
-    'buffer_provider',
-    'experimental_components',
-    ...(isNoStd ? noStdFeatures : stdFeatures),
-  };
-  final arguments = [
-    if (buildStatic || isNoStd) '+nightly',
-    'rustc',
-    '--manifest-path=$workingDirectory/ffi/capi/Cargo.toml',
-    '--crate-type=${buildStatic ? 'staticlib' : 'cdylib'}',
-    '--release',
-    '--config=profile.release.panic="abort"',
-    '--config=profile.release.codegen-units=1',
-    '--no-default-features',
-    '--features=${features.join(',')}',
-    if (isNoStd) '-Zbuild-std=core,alloc',
-    if (buildStatic || isNoStd) ...[
-      '-Zbuild-std=std,panic_abort',
-      '-Zbuild-std-features=panic_immediate_abort',
-    ],
-    '--target=$target',
-  ];
-  await runProcess('cargo', arguments, workingDirectory: workingDirectory);
-
-  final builtPath = path.join(
-    workingDirectory,
-    'target',
-    target,
-    'release',
-    libFileName,
-  );
-  final file = File(builtPath);
-  if (!(await file.exists())) {
-    throw FileSystemException('Building the dylib failed', builtPath);
-  }
-  await file.copy(libFileUri.toFilePath(windows: Platform.isWindows));
-  return libFileUri;
-}
-
-String asRustTarget(BuildInput input) {
-  final rustTarget = _asRustTarget(
-    input.config.code.targetOS,
-    input.config.code.targetArchitecture,
-    input.config.code.targetOS == OS.iOS &&
-        input.config.code.iOS.targetSdk == 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';
-  }
-  return switch ((os, architecture)) {
-    (OS.android, Architecture.arm) => 'armv7-linux-androideabi',
-    (OS.android, Architecture.arm64) => 'aarch64-linux-android',
-    (OS.android, Architecture.ia32) => 'i686-linux-android',
-    (OS.android, Architecture.riscv64) => 'riscv64-linux-android',
-    (OS.android, Architecture.x64) => 'x86_64-linux-android',
-    (OS.fuchsia, Architecture.arm64) => 'aarch64-unknown-fuchsia',
-    (OS.fuchsia, Architecture.x64) => 'x86_64-unknown-fuchsia',
-    (OS.iOS, Architecture.arm64) => 'aarch64-apple-ios',
-    (OS.iOS, Architecture.x64) => 'x86_64-apple-ios',
-    (OS.linux, Architecture.arm) => 'armv7-unknown-linux-gnueabihf',
-    (OS.linux, Architecture.arm64) => 'aarch64-unknown-linux-gnu',
-    (OS.linux, Architecture.ia32) => 'i686-unknown-linux-gnu',
-    (OS.linux, Architecture.riscv32) => 'riscv32gc-unknown-linux-gnu',
-    (OS.linux, Architecture.riscv64) => 'riscv64gc-unknown-linux-gnu',
-    (OS.linux, Architecture.x64) => 'x86_64-unknown-linux-gnu',
-    (OS.macOS, Architecture.arm64) => 'aarch64-apple-darwin',
-    (OS.macOS, Architecture.x64) => 'x86_64-apple-darwin',
-    (OS.windows, Architecture.arm64) => 'aarch64-pc-windows-msvc',
-    (OS.windows, Architecture.ia32) => 'i686-pc-windows-msvc',
-    (OS.windows, Architecture.x64) => 'x86_64-pc-windows-msvc',
-    (_, _) =>
-      throw UnimplementedError(
-        'Target ${(os, architecture)} not available for rust',
-      ),
-  };
-}
-
-bool _isNoStdTarget((OS os, Architecture? architecture) arg) => [
-  (OS.android, Architecture.riscv64),
-  (OS.linux, Architecture.riscv64),
-].contains(arg);
-
 extension on BuildConfig {
   bool buildStatic(bool treeshake) =>
       code.linkModePreference == LinkModePreference.static ||

pkgs/intl4x/hook/link.dart

@@ -31,20 +31,28 @@ Future<void> main(List<String> args) async {
 
     output.addDependency(staticLib.file!);
 
-    final usedSymbols = input.usages
-        .instancesOf(recordSymbolId)!
-        .map(
-          (instance) =>
-              // Get the "symbol" field value from "RecordSymbol"
-              (instance.instanceConstant.fields.values.first
-                      as record_use.StringConstant)
-                  .value,
-        );
+    final usages = input.usages;
+    Iterable<String>? usedSymbols;
+    if (usages == null) {
+      usedSymbols = null;
+    } else {
+      usedSymbols = usages
+          .instancesOf(recordSymbolId)!
+          .map(
+            (instance) =>
+                // Get the "symbol" field value from "RecordSymbol"
+                (instance.instanceConstant.fields.values.first
+                        as record_use.StringConstant)
+                    .value,
+          );
+    }
+    print('Using symbols: $usedSymbols');
+    final linkerOptions = LinkerOptions.treeshake(symbols: usedSymbols);
     final linker = CLinker.library(
       name: input.packageName,
       assetName: assetId,
       sources: [staticLib.file!.path],
-      linkerOptions: LinkerOptions.treeshake(symbols: usedSymbols),
+      linkerOptions: linkerOptions,
     );
     await linker.run(
       input: input,
@@ -58,9 +66,11 @@ Future<void> main(List<String> args) async {
 }
 
 extension on LinkInput {
-  record_use.RecordedUsages get usages {
-    final usagesFile = recordedUsagesFile;
-    final usagesContent = File.fromUri(usagesFile!).readAsStringSync();
+  record_use.RecordedUsages? get usages {
+    if (recordedUsagesFile == null) {
+      return null;
+    }
+    final usagesContent = File.fromUri(recordedUsagesFile!).readAsStringSync();
     final usagesJson = jsonDecode(usagesContent) as Map<String, dynamic>;
     return record_use.RecordedUsages.fromJson(usagesJson);
   }