blob: f8043857f2371f49d114ac37dbf3869154257cfe [file] [log] [blame]
// Copyright (c) 2020, 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.
// @dart = 2.9
import 'dart:io' show Directory, Platform;
import 'package:_fe_analyzer_shared/src/testing/id.dart';
import 'package:_fe_analyzer_shared/src/testing/id_testing.dart'
show DataInterpreter, runTests;
import 'package:_fe_analyzer_shared/src/testing/id_testing.dart';
import 'package:front_end/src/api_prototype/compiler_options.dart';
import 'package:front_end/src/api_prototype/experimental_flags.dart'
show ExperimentalFlag;
import 'package:front_end/src/base/nnbd_mode.dart';
import 'package:front_end/src/testing/id_testing_helper.dart';
import 'package:kernel/ast.dart';
import 'package:kernel/src/printer.dart';
const String normalMarker = 'normal';
const String verboseMarker = 'verbose';
const String limitedMarker = 'limited';
const String statementMarker = 'stmt';
const String expressionMarker = 'expr';
const AstTextStrategy normalStrategy = const AstTextStrategy(
includeLibraryNamesInMembers: false,
includeLibraryNamesInTypes: false,
includeAuxiliaryProperties: false,
useMultiline: true,
maxExpressionDepth: null,
maxExpressionsLength: null,
maxStatementDepth: null,
maxStatementsLength: null);
const AstTextStrategy verboseStrategy = const AstTextStrategy(
includeLibraryNamesInMembers: true,
includeLibraryNamesInTypes: true,
includeAuxiliaryProperties: true,
useMultiline: true,
maxExpressionDepth: null,
maxExpressionsLength: null,
maxStatementDepth: null,
maxStatementsLength: null);
const AstTextStrategy limitedStrategy = const AstTextStrategy(
includeLibraryNamesInMembers: false,
includeLibraryNamesInTypes: false,
includeAuxiliaryProperties: false,
useMultiline: false,
maxExpressionDepth: 5,
maxExpressionsLength: 4,
maxStatementDepth: 5,
maxStatementsLength: 4);
AstTextStrategy getStrategy(String marker) {
switch (marker) {
case normalMarker:
return normalStrategy;
case verboseMarker:
return verboseStrategy;
case limitedMarker:
return limitedStrategy;
}
throw new UnsupportedError("Unexpected marker '${marker}'.");
}
main(List<String> args) async {
Directory dataDir = new Directory.fromUri(Platform.script.resolve('data'));
await runTests<String>(dataDir,
args: args,
createUriForFileName: createUriForFileName,
onFailure: onFailure,
preserveWhitespaceInAnnotations: true,
runTest: runTestFor(const TextRepresentationDataComputer(), [
const TextRepresentationConfig(normalMarker, 'normal'),
const TextRepresentationConfig(verboseMarker, 'verbose'),
const TextRepresentationConfig(limitedMarker, 'limited'),
]));
}
class TextRepresentationConfig extends TestConfig {
const TextRepresentationConfig(String marker, String name)
: super(marker, name,
explicitExperimentalFlags: const {
ExperimentalFlag.nonNullable: true
},
nnbdMode: NnbdMode.Strong);
void customizeCompilerOptions(CompilerOptions options, TestData testData) {
if (testData.name.endsWith('_opt_out.dart')) {
options.nnbdMode = NnbdMode.Weak;
}
}
}
class TextRepresentationDataComputer extends DataComputer<String> {
const TextRepresentationDataComputer();
void computeLibraryData(
TestConfig config,
InternalCompilerResult compilerResult,
Library library,
Map<Id, ActualData<String>> actualMap,
{bool verbose}) {
new TextRepresentationDataExtractor(
compilerResult, actualMap, getStrategy(config.marker))
.computeForLibrary(library);
}
@override
void computeMemberData(
TestConfig config,
InternalCompilerResult compilerResult,
Member member,
Map<Id, ActualData<String>> actualMap,
{bool verbose}) {
member.accept(new TextRepresentationDataExtractor(
compilerResult, actualMap, getStrategy(config.marker)));
}
@override
DataInterpreter<String> get dataValidator => const StringDataInterpreter();
}
class TextRepresentationDataExtractor extends CfeDataExtractor<String> {
final AstTextStrategy strategy;
TextRepresentationDataExtractor(InternalCompilerResult compilerResult,
Map<Id, ActualData<String>> actualMap, this.strategy)
: super(compilerResult, actualMap);
@override
String computeLibraryValue(Id id, Library node) {
return 'nnbd=${node.isNonNullableByDefault}';
}
@override
visitProcedure(Procedure node) {
if (!node.name.text.startsWith(expressionMarker) &&
!node.name.text.startsWith(statementMarker)) {
node.function.accept(this);
}
computeForMember(node);
}
@override
visitField(Field node) {
if (!node.name.text.startsWith(expressionMarker) &&
!node.name.text.startsWith(statementMarker)) {
node.initializer?.accept(this);
}
computeForMember(node);
}
@override
String computeMemberValue(Id id, Member node) {
if (node.name.text == 'stmtVariableDeclarationMulti') {
print(node);
}
if (node.name.text.startsWith(expressionMarker)) {
if (node is Procedure) {
Statement body = node.function.body;
if (body is ReturnStatement) {
return body.expression.toText(strategy);
}
} else if (node is Field && node.initializer != null) {
return node.initializer.toText(strategy);
}
} else if (node.name.text.startsWith(statementMarker)) {
if (node is Procedure) {
Statement body = node.function.body;
if (body is Block && body.statements.length == 1) {
// Prefix with newline to make multiline text representations more
// readable.
return '\n${body.statements.single.toText(strategy)}';
}
}
}
return null;
}
@override
String computeNodeValue(Id id, TreeNode node) {
if (node is ConstantExpression) {
return node.constant.toText(strategy);
} else if (node is VariableDeclaration) {
DartType type = node.type;
if (type is FunctionType && type.typedefType != null) {
return type.typedefType.toText(strategy);
} else {
return type.toText(strategy);
}
}
return null;
}
}