blob: 4208d17f82ef13160caf24a14799cc21ef84d58c [file] [log] [blame]
// 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.md file.
library fasta.test.incremental_test;
import "dart:async" show Future;
import "dart:convert" show JsonEncoder;
import "dart:io" show File;
import "package:kernel/ast.dart" show Component;
import "package:testing/testing.dart"
show Chain, ChainContext, Result, Step, TestDescription, runMe;
import "package:testing/src/log.dart" show splitLines;
import "package:yaml/yaml.dart" show YamlMap, loadYamlNode;
import "package:front_end/src/api_prototype/compiler_options.dart"
show CompilerOptions, DiagnosticMessage;
import "package:front_end/src/api_prototype/incremental_kernel_generator.dart"
show IncrementalKernelGenerator;
import "package:front_end/src/api_prototype/memory_file_system.dart"
show MemoryFileSystem;
import "package:front_end/src/api_prototype/terminal_color_support.dart"
show printDiagnosticMessage;
import 'package:front_end/src/compute_platform_binaries_location.dart'
show computePlatformBinariesLocation;
import 'package:front_end/src/external_state_snapshot.dart'
show ExternalStateSnapshot;
import 'package:front_end/src/base/processed_options.dart'
show ProcessedOptions;
import 'package:front_end/src/fasta/compiler_context.dart' show CompilerContext;
import 'package:front_end/src/fasta/incremental_compiler.dart'
show IncrementalCompiler;
import 'package:front_end/src/fasta/severity.dart' show Severity;
import "incremental_expectations.dart"
show IncrementalExpectation, extractJsonExpectations;
import "incremental_source_files.dart" show expandDiff, expandUpdates;
const JsonEncoder json = const JsonEncoder.withIndent(" ");
final Uri base = Uri.parse("org-dartlang-test:///");
final Uri entryPoint = base.resolve("main.dart");
class Context extends ChainContext {
final CompilerContext compilerContext;
final ExternalStateSnapshot snapshot;
final List<DiagnosticMessage> errors;
final List<Step> steps = const <Step>[
const ReadTest(),
const RunCompilations(),
];
final IncrementalKernelGenerator compiler;
Context(this.compilerContext, this.snapshot, this.errors)
: compiler = new IncrementalCompiler(compilerContext);
ProcessedOptions get options => compilerContext.options;
MemoryFileSystem get fileSystem => options.fileSystem;
Future<T> runInContext<T>(Future<T> action(CompilerContext c)) {
return compilerContext.runInContext<T>(action);
}
void reset() {
errors.clear();
snapshot.restore();
}
List<DiagnosticMessage> takeErrors() {
List<DiagnosticMessage> result = new List<DiagnosticMessage>.from(errors);
errors.clear();
return result;
}
}
class ReadTest extends Step<TestDescription, TestCase, Context> {
const ReadTest();
String get name => "read test";
Future<Result<TestCase>> run(
TestDescription description, Context context) async {
context.reset();
Uri uri = description.uri;
String contents = await new File.fromUri(uri).readAsString();
Map<String, List<String>> sources = <String, List<String>>{};
List<IncrementalExpectation> expectations;
bool firstPatch = true;
YamlMap map = loadYamlNode(contents, sourceUrl: uri);
map.forEach((_fileName, _contents) {
String fileName = _fileName; // Strong mode hurray!
String contents = _contents; // Strong mode hurray!
if (fileName.endsWith(".patch")) {
fileName = fileName.substring(0, fileName.length - ".patch".length);
if (firstPatch) {
expectations = extractJsonExpectations(contents);
}
sources[fileName] = expandUpdates(expandDiff(contents));
firstPatch = false;
} else {
sources[fileName] = <String>[contents];
}
});
final TestCase test = new TestCase(description, sources, expectations);
return test.validate(this);
}
}
class RunCompilations extends Step<TestCase, TestCase, Context> {
const RunCompilations();
String get name => "run compilations";
Future<Result<TestCase>> run(TestCase test, Context context) async {
for (int edits = 0;; edits++) {
bool foundSources = false;
test.sources.forEach((String name, List<String> sources) {
if (edits < sources.length) {
String source = sources[edits];
Uri uri = base.resolve(name);
context.fileSystem.entityForUri(uri).writeAsStringSync(source);
foundSources = true;
context.compiler.invalidate(uri);
if (edits == 0) {
print("==> $uri <==");
} else {
print("==> $uri (edit #$edits) <==");
}
print(source.trimRight());
}
});
if (!foundSources) {
return edits == 0 ? fail(test, "No sources found") : pass(test);
}
var compiler = context.compiler;
Component component =
await compiler.computeDelta(entryPoints: [entryPoint]);
List<DiagnosticMessage> errors = context.takeErrors();
if (test.expectations[edits].hasCompileTimeError) {
if (errors.isEmpty) {
return fail(test, "Compile-time error expected, but none reported");
}
} else if (errors.isNotEmpty) {
String indentedErrors =
splitLines(errors.map((e) => e.ansiFormatted.join("\n")).join("\n"))
.join(" ");
return fail(test, "Unexpected compile-time errors:\n $indentedErrors");
} else if (component.libraries.length < 1) {
return fail(test, "The compiler detected no changes");
}
}
}
}
class TestCase {
final TestDescription description;
final Map<String, List<String>> sources;
final List<IncrementalExpectation> expectations;
TestCase(this.description, this.sources, this.expectations);
String toString() {
return "TestCase(${json.convert(sources)}, ${json.convert(expectations)})";
}
Result<TestCase> validate(Step<dynamic, TestCase, ChainContext> step) {
print(this);
if (sources == null) {
return step.fail(this, "No sources.");
}
if (expectations == null || expectations.isEmpty) {
return step.fail(this, "No expectations.");
}
for (String name in sources.keys) {
List<String> versions = sources[name];
if (versions.length != 1 && versions.length != expectations.length) {
return step.fail(
this,
"Found ${versions.length} versions of $name,"
" but expected 1 or ${expectations.length}.");
}
}
return step.pass(this);
}
}
Future<Context> createContext(
Chain suite, Map<String, String> environment) async {
/// The custom URI used to locate the dill file in the MemoryFileSystem.
final Uri sdkSummary = base.resolve("vm_platform.dill");
/// The actual location of the dill file.
final Uri sdkSummaryFile =
computePlatformBinariesLocation(forceBuildDir: true)
.resolve("vm_platform.dill");
final MemoryFileSystem fs = new MemoryFileSystem(base);
fs
.entityForUri(sdkSummary)
.writeAsBytesSync(await new File.fromUri(sdkSummaryFile).readAsBytes());
final List<DiagnosticMessage> errors = <DiagnosticMessage>[];
final CompilerOptions optionBuilder = new CompilerOptions()
..legacyMode = true
..verbose = true
..fileSystem = fs
..sdkSummary = sdkSummary
..onDiagnostic = (DiagnosticMessage message) {
printDiagnosticMessage(message, print);
if (message.severity == Severity.error) {
errors.add(message);
}
};
final ProcessedOptions options =
new ProcessedOptions(options: optionBuilder, inputs: [entryPoint]);
final ExternalStateSnapshot snapshot =
new ExternalStateSnapshot(await options.loadSdkSummary(null));
return new Context(new CompilerContext(options), snapshot, errors);
}
main([List<String> arguments = const []]) =>
runMe(arguments, createContext, "../../testing.json");