build/lib/src/generate/run_builder.dart

// Copyright (c) 2017, 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:isolate';

import 'package:logging/logging.dart';
import 'package:package_config/package_config.dart';

import '../analyzer/resolver.dart';
import '../asset/id.dart';
import '../asset/reader.dart';
import '../asset/writer.dart';
import '../builder/build_step.dart';
import '../builder/build_step_impl.dart';
import '../builder/builder.dart';
import '../builder/logging.dart';
import '../resource/resource.dart';
import 'expected_outputs.dart';

/// Run [builder] with each asset in [inputs] as the primary input.
///
/// Builds for all inputs are run asynchronously and ordering is not guaranteed.
/// The [log] instance inside the builds will be scoped to [logger] which is
/// defaulted to a [Logger] name 'runBuilder'.
///
/// If a [resourceManager] is provided it will be used and it will not be
/// automatically disposed of (its up to the caller to dispose of it later). If
/// one is not provided then one will be created and disposed at the end of
/// this function call.
///
/// If [reportUnusedAssetsForInput] is provided then all calls to
/// `BuildStep.reportUnusedAssets` in [builder] will be forwarded to this
/// function with the associated primary input.
Future<void> runBuilder(
  Builder builder,
  Iterable<AssetId> inputs,
  AssetReader reader,
  AssetWriter writer,
  Resolvers? resolvers, {
  Logger? logger,
  ResourceManager? resourceManager,
  StageTracker stageTracker = NoOpStageTracker.instance,
  void Function(AssetId input, Iterable<AssetId> assets)?
      reportUnusedAssetsForInput,
  PackageConfig? packageConfig,
}) async {
  var shouldDisposeResourceManager = resourceManager == null;
  final resources = resourceManager ?? ResourceManager();
  logger ??= Logger('runBuilder');

  PackageConfig? transformedConfig;

  Future<PackageConfig> loadPackageConfig() async {
    if (transformedConfig != null) return transformedConfig!;

    var config = packageConfig;
    if (config == null) {
      final uri = await Isolate.packageConfig;

      if (uri == null) {
        throw UnsupportedError(
            'Isolate running the build does not have a package config and no '
            'fallback has been provided');
      }

      config = await loadPackageConfigUri(uri);
    }

    return transformedConfig = config.transformToAssetUris();
  }

  //TODO(nbosch) check overlapping outputs?
  Future<void> buildForInput(AssetId input) async {
    var outputs = expectedOutputs(builder, input);
    if (outputs.isEmpty) return;
    var buildStep = BuildStepImpl(
        input, outputs, reader, writer, resolvers, resources, loadPackageConfig,
        stageTracker: stageTracker,
        reportUnusedAssets: reportUnusedAssetsForInput == null
            ? null
            : (assets) => reportUnusedAssetsForInput(input, assets));
    try {
      await builder.build(buildStep);
    } finally {
      await buildStep.complete();
    }
  }

  await scopeLogAsync(() => Future.wait(inputs.map(buildForInput)), logger);

  if (shouldDisposeResourceManager) {
    await resources.disposeAll();
    await resources.beforeExit();
  }
}

extension on Package {
  static final _lib = Uri.parse('lib/');

  Package transformToAssetUris() {
    return Package(
      name,
      Uri(scheme: 'asset', pathSegments: [name, '']),
      packageUriRoot: _lib,
      extraData: extraData,
      languageVersion: languageVersion,
    );
  }
}

extension on PackageConfig {
  PackageConfig transformToAssetUris() {
    return PackageConfig(
      [
        for (final package in packages) package.transformToAssetUris(),
      ],
      extraData: extraData,
    );
  }
}