languages/dart-sdk
languages/dart-sdk
1
0
Fork 0
mirror of https://github.com/dart-lang/sdk synced 2024-10-14 09:12:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

[kernel] Delete bin/transform.dart

Browse source 
Change-Id: I92b9f13d4e541c080fa29c9a79df0c925eebcc7a
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/159241
Commit-Queue: Johnni Winther <johnniwinther@google.com>
Reviewed-by: Jens Johansen <jensj@google.com>
This commit is contained in:
Johnni Winther 2020-08-19 13:07:41 +00:00 committed by commit-bot@chromium.org
parent d79ef922a5
commit e7d0947811
4 changed files with 0 additions and 256 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

112
pkg/front_end/test/whole_program_test.dart
View file

@ -1,112 +0,0 @@
// 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' show Future;
import 'dart:io' show Directory, File, Platform;
import 'package:async_helper/async_helper.dart' show asyncEnd, asyncStart;
import 'package:testing/testing.dart' show StdioProcess;
import 'package:front_end/src/compute_platform_binaries_location.dart'
show computePlatformBinariesLocation;
final Uri compiler = Uri.base.resolve('pkg/front_end/tool/_fasta/compile.dart');
final Uri transform = Uri.base.resolve('pkg/kernel/bin/transform.dart');
final Uri dump = Uri.base.resolve('pkg/kernel/bin/dump.dart');
final Uri packagesFile = Uri.base.resolve('.packages');
final Uri dartVm =
Uri.base.resolveUri(new Uri.file(Platform.resolvedExecutable));
Future main() async {
asyncStart();
final Directory tmp = await Directory.systemTemp.createTemp('whole_program');
final Uri dartFile = tmp.uri.resolve('hello.dart');
final Uri dillFile = tmp.uri.resolve('hello.dart.dill');
final Uri constantsDillFile = tmp.uri.resolve('hello.dart.constants.dill');
final Uri constantsDillTxtFile =
tmp.uri.resolve('hello.dart.constants.dill.txt');
// Write the hello world file.
await new File(dartFile.toFilePath()).writeAsString('''
// Ensure we import a big program!
import 'package:compiler/src/dart2js.dart';
import 'package:front_end/src/fasta/kernel/kernel_target.dart';
void main() => print('hello world!');
''');
try {
await runCompiler(dartFile, dillFile);
await transformDillFile(dillFile, constantsDillFile);
await dumpDillFile(constantsDillFile, constantsDillTxtFile);
await runHelloWorld(constantsDillFile);
} finally {
await tmp.delete(recursive: true);
}
asyncEnd();
}
Future runCompiler(Uri input, Uri output) async {
final Uri platformDill = computePlatformBinariesLocation(forceBuildDir: true)
.resolve("vm_platform_strong.dill");
final List<String> arguments = <String>[
'--packages=${packagesFile.toFilePath()}',
'-c',
compiler.toFilePath(),
'--platform=${platformDill.toFilePath()}',
'--output=${output.toFilePath()}',
'--packages=${packagesFile.toFilePath()}',
'--verify',
input.toFilePath(),
];
await run('Compilation of hello.dart', arguments);
}
Future transformDillFile(Uri from, Uri to) async {
final List<String> arguments = <String>[
transform.toFilePath(),
'-f',
'bin',
'-t',
'constants',
'-o',
to.toFilePath(),
from.toFilePath(),
];
await run('Transforming $from --to--> $to', arguments);
}
Future dumpDillFile(Uri dillFile, Uri txtFile) async {
final List<String> arguments = <String>[
dump.toFilePath(),
dillFile.toFilePath(),
txtFile.toFilePath(),
];
await run('Dumping $dillFile --to--> $txtFile', arguments);
}
Future runHelloWorld(Uri dillFile) async {
final List<String> arguments = <String>[dillFile.toFilePath()];
await run('Running hello.dart', arguments, 'hello world!\n');
}
Future run(String message, List<String> arguments,
[String expectedOutput]) async {
final Stopwatch sw = new Stopwatch()..start();
print('Running:\n ${dartVm.toFilePath()} ${arguments.join(' ')}');
StdioProcess result = await StdioProcess.run(dartVm.toFilePath(), arguments,
timeout: const Duration(seconds: 120));
print('Output:\n ${result.output.replaceAll('\n', ' \n')}');
print('ExitCode: ${result.exitCode}');
print('Took: ${sw.elapsed}\n\n');
if ((expectedOutput != null && result.output != expectedOutput) ||
result.exitCode != 0) {
throw '$message failed.';
}
}

138
pkg/kernel/bin/transform.dart
View file

@ -1,138 +0,0 @@
#!/usr/bin/env dart
// Copyright (c) 2016, 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 'dart:io';
import 'package:front_end/src/api_prototype/constant_evaluator.dart'
as constants show EvaluationMode, SimpleErrorReporter, transformComponent;
import 'package:args/args.dart';
import 'package:kernel/class_hierarchy.dart';
import 'package:kernel/core_types.dart';
import 'package:kernel/kernel.dart';
import 'package:kernel/src/tool/batch_util.dart';
import 'package:kernel/target/targets.dart';
import 'package:kernel/transformations/continuation.dart' as cont;
import 'package:kernel/transformations/empty.dart' as empty;
import 'package:kernel/transformations/value_class.dart' as valueClass;
import 'package:kernel/transformations/mixin_full_resolution.dart' as mix;
import 'package:kernel/type_environment.dart';
import 'package:kernel/vm/constants_native_effects.dart';
ArgParser parser = new ArgParser()
..addOption('format',
abbr: 'f',
allowed: ['text', 'bin'],
defaultsTo: 'bin',
help: 'Output format.')
..addOption('out', abbr: 'o', help: 'Output file.', defaultsTo: null)
..addFlag('verbose',
abbr: 'v',
negatable: false,
help: 'Be verbose (e.g. prints transformed main library).',
defaultsTo: false)
..addMultiOption('define', abbr: 'D', splitCommas: false)
..addOption('transformation',
abbr: 't',
help: 'The transformation to apply.',
defaultsTo: 'continuation');
main(List<String> arguments) async {
if (arguments.isNotEmpty && arguments[0] == '--batch') {
if (arguments.length != 1) {
throw '--batch cannot be used with other arguments';
}
await runBatch((arguments) => runTransformation(arguments));
} else {
CompilerOutcome outcome = await runTransformation(arguments);
exit(outcome == CompilerOutcome.Ok ? 0 : 1);
}
}
Future<CompilerOutcome> runTransformation(List<String> arguments) async {
ArgResults options = parser.parse(arguments);
if (options.rest.length != 1) {
throw 'Usage:\n${parser.usage}';
}
var input = options.rest.first;
var output = options['out'];
var format = options['format'];
var verbose = options['verbose'];
Map<String, String> defines = <String, String>{};
for (String define in options['define']) {
int index = define.indexOf('=');
String name;
String expression;
if (index != -1) {
name = define.substring(0, index);
expression = define.substring(index + 1);
} else {
name = define;
expression = define;
}
defines[name] = expression;
}
if (output == null) {
output = '${input.substring(0, input.lastIndexOf('.'))}.transformed.dill';
}
var component = loadComponentFromBinary(input);
final coreTypes = new CoreTypes(component);
final hierarchy = new ClassHierarchy(component, coreTypes);
final typeEnvironment = new TypeEnvironment(coreTypes, hierarchy);
switch (options['transformation']) {
case 'continuation':
bool productMode = defines["dart.vm.product"] == "true";
component = cont.transformComponent(typeEnvironment, component,
productMode: productMode);
break;
case 'resolve-mixins':
mix.transformLibraries(new NoneTarget(null), coreTypes, hierarchy,
component.libraries, null);
break;
case 'constants':
final VmConstantsBackend backend = new VmConstantsBackend(coreTypes);
component = constants.transformComponent(component, backend, defines,
const constants.SimpleErrorReporter(), constants.EvaluationMode.weak,
desugarSets: false,
evaluateAnnotations: true,
enableTripleShift: false,
errorOnUnevaluatedConstant: false);
break;
case 'value-class':
component = valueClass.transformComponent(component);
break;
case 'empty':
component = empty.transformComponent(component);
break;
default:
throw 'Unknown transformation';
}
// TODO(30631): Fix the verifier so we can check that the transform produced
// valid output.
//
// verifyComponent(component);
if (format == 'text') {
writeComponentToText(component, path: output);
} else {
assert(format == 'bin');
await writeComponentToBinary(component, output);
}
if (verbose) {
writeLibraryToText(component.mainMethod.parent as Library);
}
return CompilerOutcome.Ok;
}

1
pkg/kernel/pubspec.yaml
View file

@ -12,6 +12,5 @@ dependencies:
meta: ^1.0.0
dev_dependencies:
expect: any
front_end: any
test: any
testing: any

5
pkg/pkg.status
View file

@ -88,7 +88,6 @@ front_end/test/fasta/types/large_app_benchmark_test: Pass, ExtraSlow
front_end/test/incremental_compiler_leak_test: Pass, Slow
front_end/test/incremental_dart2js_test: Pass, Slow
front_end/test/minimal_incremental_kernel_generator_test: Slow, Pass
front_end/test/whole_program_test: Slow, Pass
front_end/testcases/*: Skip # These are not tests but input for tests.
front_end/tool/incremental_perf_test: Slow, Pass
kernel/test/closures_test: Slow, Pass
@ -186,7 +185,6 @@ front_end/test/fasta/bootstrap_test: Skip # Issue 31902
front_end/test/fasta/strong_test: Pass, Slow, Timeout
front_end/test/fasta/text_serialization_test: Pass, Slow, Timeout
front_end/test/incremental_dart2js_load_from_dill_test: Pass, Slow
front_end/test/whole_program_test: Skip # Issue 31902
[ $browser ]
*/test/analyzer_test: SkipByDesign # No need to run analysis tests on browser bots
@ -288,9 +286,6 @@ analyzer/test/src/task/strong/front_end_inference_test: Slow, Pass
[ $runtime == vm && ($arch == armv6 || $arch == simarm || $arch == simarm64 || $arch == simarmv6) ]
*: Skip
[ $arch != x64 || $compiler != none || $mode != release || $runtime != vm ]
front_end/test/whole_program_test: SkipByDesign
[ $mode == debug || $runtime != vm || $system == android ]
vm/test/modular_kernel_plus_aot_test: SkipByDesign # This test should only run if binary is run from build dir