mirror of
https://github.com/dart-lang/sdk
synced 2024-09-16 03:17:55 +00:00
b48584d3d0
This CL:
* introduces the Dart API to operate over libraries specifications and describes
the format we intend to use (see libraries_spec.dart)
* implements serialization/deserialization for this API
* switches over the front_end to use these APIs
* public options accept a URI to the JSON file and no longer
accept a `dartLibraries` map
* internal code uses the LibrariesSpecification API
* switches other dependencies on these APIs (resynthesizer_test and patch_sdk.dart)
This is the first step in migrating over to use the libraries.json format and
eventually remove the patched_sdk step. In particular, some of the next steps
include:
* add a build step to generate .json files from .yaml files
* add a libraries.yaml file for the sdk
* split the patched_sdk step in two:
* patching files
* generating .dill files
* add any missing support for patch-files in fasta
* finally remove the patching files step, and only have a build step for generating
.dill files
BUG=
R=ahe@google.com, paulberry@google.com, scheglov@google.com
Committed: abf2d23af2
Review-Url: https://codereview.chromium.org/2986303003 .
112 lines
4.9 KiB
Dart
112 lines
4.9 KiB
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:async';
|
|
|
|
import 'package:front_end/src/base/processed_options.dart';
|
|
import 'package:front_end/src/incremental_kernel_generator_impl.dart';
|
|
import 'package:front_end/src/fasta/compiler_context.dart';
|
|
import 'package:kernel/kernel.dart';
|
|
|
|
import 'compiler_options.dart';
|
|
|
|
/// The type of the function that clients can pass to track used files.
|
|
///
|
|
/// When a file is first used during compilation, this function is called with
|
|
/// the [Uri] of that file and [used] == `true`. The content of the file is not
|
|
/// read until the [Future] returned by the function completes. If, during a
|
|
/// subsequent compilation, a file that was being used is no longer used, then
|
|
/// the function is called with the [Uri] of that file and [used] == `false`.
|
|
///
|
|
/// Multiple invocations of may be running concurrently.
|
|
///
|
|
typedef Future<Null> WatchUsedFilesFn(Uri uri, bool used);
|
|
|
|
/// Represents the difference between "old" and "new" states of a program.
|
|
///
|
|
/// Not intended to be implemented or extended by clients.
|
|
class DeltaProgram {
|
|
/// The new state of the program.
|
|
///
|
|
/// It includes full kernels for changed libraries and for libraries that
|
|
/// are affected by the transitive change of API in the changed libraries.
|
|
///
|
|
/// For VM reload purposes we need to provide also full kernels for the
|
|
/// libraries that are transitively imported by the entry point and
|
|
/// transitively import a changed library.
|
|
///
|
|
/// Also includes external references to other libraries that were not
|
|
/// modified or affected.
|
|
final Program newProgram;
|
|
|
|
DeltaProgram(this.newProgram);
|
|
|
|
/// TODO(paulberry): add information about libraries that were removed.
|
|
}
|
|
|
|
/// Interface for generating an initial kernel representation of a program and
|
|
/// keeping it up to date as incremental changes are made.
|
|
///
|
|
/// This class maintains an internal "previous program state"; each
|
|
/// time [computeDelta] is called, it updates the previous program state and
|
|
/// produces a representation of what has changed. When there are few changes,
|
|
/// a call to [computeDelta] should be much faster than compiling the whole
|
|
/// program from scratch.
|
|
///
|
|
/// This class also maintains a set of "valid sources", which is a (possibly
|
|
/// empty) subset of the sources constituting the previous program state. Files
|
|
/// in this set are assumed to be unchanged since the last call to
|
|
/// [computeDelta].
|
|
///
|
|
/// Behavior is undefined if the client does not obey the following concurrency
|
|
/// restrictions:
|
|
/// - no two invocations of [computeDelta] may be outstanding at any given time.
|
|
/// - neither [invalidate] nor [invalidateAll] may be called while an invocation
|
|
/// of [computeDelta] is outstanding.
|
|
///
|
|
/// Not intended to be implemented or extended by clients.
|
|
abstract class IncrementalKernelGenerator {
|
|
/// Generates a kernel representation of the changes to the program, assuming
|
|
/// that all valid sources are unchanged since the last call to
|
|
/// [computeDelta].
|
|
///
|
|
/// Source files in the set of valid sources are guaranteed not to be re-read
|
|
/// from disk; they are assumed to be unchanged regardless of the state of the
|
|
/// filesystem.
|
|
///
|
|
/// If the future completes successfully, the previous file state is updated
|
|
/// and the set of valid sources is set to the set of all sources in the
|
|
/// program.
|
|
///
|
|
/// If the future completes with an error (due to errors in the compiled
|
|
/// source code), the caller may consider the previous file state and the set
|
|
/// of valid sources to be unchanged; this means that once the user fixes the
|
|
/// errors, it is safe to call [computeDelta] again.
|
|
Future<DeltaProgram> computeDelta();
|
|
|
|
/// Remove the file associated with the given file [uri] from the set of
|
|
/// valid files. This guarantees that those files will be re-read on the
|
|
/// next call to [computeDelta]).
|
|
void invalidate(Uri uri);
|
|
|
|
/// Creates an [IncrementalKernelGenerator] which is prepared to generate
|
|
/// kernel representations of the program whose main library is in the given
|
|
/// [entryPoint].
|
|
///
|
|
/// The initial "previous program state" is an empty program containing no
|
|
/// code, and the initial set of valid sources is empty. To obtain a kernel
|
|
/// representation of the program, call [computeDelta].
|
|
static Future<IncrementalKernelGenerator> newInstance(
|
|
CompilerOptions options, Uri entryPoint,
|
|
{WatchUsedFilesFn watch}) async {
|
|
var processedOptions = new ProcessedOptions(options, false, [entryPoint]);
|
|
return await CompilerContext.runWithOptions(processedOptions, (_) async {
|
|
var uriTranslator = await processedOptions.getUriTranslator();
|
|
return new IncrementalKernelGeneratorImpl(
|
|
processedOptions, uriTranslator, entryPoint,
|
|
watch: watch);
|
|
});
|
|
}
|
|
}
|