blob: 7cfefba88ed9b2922e75f35907d9852624e22284 [file] [log] [blame]
// Copyright (c) 2015, 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.
library dart2js.serialization_model_test;
import 'dart:async';
import 'package:async_helper/async_helper.dart';
import 'package:expect/expect.dart';
import 'package:compiler/src/closure.dart';
import 'package:compiler/src/commandline_options.dart';
import 'package:compiler/src/common_elements.dart';
import 'package:compiler/src/constants/values.dart';
import 'package:compiler/src/compiler.dart';
import 'package:compiler/src/deferred_load.dart';
import 'package:compiler/src/elements/elements.dart';
import 'package:compiler/src/elements/entities.dart';
import 'package:compiler/src/js_backend/js_backend.dart';
import 'package:compiler/src/serialization/equivalence.dart';
import 'package:compiler/src/tree/nodes.dart';
import 'package:compiler/src/world.dart';
import '../memory_compiler.dart';
import '../equivalence/check_helpers.dart';
import '../equivalence/check_functions.dart';
import 'helper.dart';
import 'test_data.dart';
/// Number of tests that are not part of the automatic test grouping.
int SKIP_COUNT = 2;
/// Number of groups that the [TESTS] are split into.
int SPLIT_COUNT = 5;
main(List<String> args) {
asyncTest(() async {
Arguments arguments = new Arguments.from(args);
SerializedData serializedData =
await serializeDartCore(arguments: arguments);
if (arguments.uri != null) {
Uri entryPoint = arguments.uri;
SerializationResult result =
await measure('${entryPoint}', 'serialize', () {
return serialize(entryPoint,
memorySourceFiles: serializedData.toMemorySourceFiles(),
resolutionInputs: serializedData.toUris(),
dataUri: Uri.parse('memory:test.data'));
});
await checkModels(entryPoint,
sourceFiles: serializedData
.toMemorySourceFiles(result.serializedData.toMemorySourceFiles()),
resolutionInputs:
serializedData.toUris(result.serializedData.toUris()));
} else {
await arguments.forEachTest(serializedData, TESTS, checkModels);
}
printMeasurementResults();
});
}
Future checkModels(Uri entryPoint,
{Map<String, String> sourceFiles: const <String, String>{},
List<Uri> resolutionInputs,
int index,
Test test,
bool verbose: false}) async {
String testDescription = test != null ? test.name : '${entryPoint}';
String id = index != null ? '$index: ' : '';
String title = '${id}${testDescription}';
Compiler compilerNormal = await measure(title, 'compile normal', () async {
Compiler compilerNormal = compilerFor(
memorySourceFiles: sourceFiles, options: [Flags.analyzeOnly]);
compilerNormal.resolution.retainCachesForTesting = true;
await compilerNormal.run(entryPoint);
ElementEnvironment elementEnvironment =
compilerNormal.frontendStrategy.elementEnvironment;
compilerNormal.closeResolution(elementEnvironment.mainFunction);
return compilerNormal;
});
Compiler compilerDeserialized =
await measure(title, 'compile deserialized', () async {
Compiler compilerDeserialized = compilerFor(
memorySourceFiles: sourceFiles,
resolutionInputs: resolutionInputs,
options: [Flags.analyzeOnly]);
compilerDeserialized.resolution.retainCachesForTesting = true;
await compilerDeserialized.run(entryPoint);
ElementEnvironment elementEnvironment =
compilerDeserialized.frontendStrategy.elementEnvironment;
compilerDeserialized.closeResolution(elementEnvironment.mainFunction);
return compilerDeserialized;
});
return measure(title, 'check models', () async {
checkAllImpacts(compilerNormal, compilerDeserialized, verbose: verbose);
ClosedWorld closedWorld1 =
compilerNormal.resolutionWorldBuilder.closedWorldForTesting;
ClosedWorld closedWorld2 =
compilerNormal.resolutionWorldBuilder.closedWorldForTesting;
checkResolutionEnqueuers(
closedWorld1.backendUsage,
closedWorld2.backendUsage,
compilerNormal.enqueuer.resolution,
compilerDeserialized.enqueuer.resolution,
verbose: verbose);
checkClosedWorlds(closedWorld1, closedWorld2,
// Serialized native data include non-live members.
allowExtra: true,
verbose: verbose);
checkBackendInfo(compilerNormal, compilerDeserialized, verbose: verbose);
});
}
void checkBackendInfo(Compiler compilerNormal, Compiler compilerDeserialized,
{bool verbose: false}) {
checkSets(
compilerNormal.enqueuer.resolution.processedEntities,
compilerDeserialized.enqueuer.resolution.processedEntities,
"Processed element mismatch",
areElementsEquivalent, onSameElement: (a, b) {
checkElements(compilerNormal, compilerDeserialized, a, b, verbose: verbose);
}, verbose: verbose);
Expect.equals(
compilerNormal.deferredLoadTask.isProgramSplit,
compilerDeserialized.deferredLoadTask.isProgramSplit,
"isProgramSplit mismatch");
Iterable<ConstantValue> constants1 =
compilerNormal.deferredLoadTask.constantsForTesting;
Iterable<ConstantValue> constants2 =
compilerDeserialized.deferredLoadTask.constantsForTesting;
checkSets(
constants1,
constants2,
'deferredLoadTask._outputUnitForConstants.keys',
areConstantValuesEquivalent,
failOnUnfound: false,
failOnExtra: false,
onSameElement: (ConstantValue value1, ConstantValue value2) {
checkOutputUnits(
compilerNormal,
compilerDeserialized,
compilerNormal.deferredLoadTask.outputUnitForConstant(value1),
compilerDeserialized.deferredLoadTask.outputUnitForConstant(value2),
'for ${value1.toStructuredText()} '
'vs ${value2.toStructuredText()}');
}, onUnfoundElement: (ConstantValue value1) {
OutputUnit outputUnit1 =
compilerNormal.deferredLoadTask.outputUnitForConstant(value1);
Expect.isTrue(outputUnit1.isMainOutput,
"Missing deferred constant: ${value1.toStructuredText()}");
}, onExtraElement: (ConstantValue value2) {
OutputUnit outputUnit2 =
compilerDeserialized.deferredLoadTask.outputUnitForConstant(value2);
Expect.isTrue(outputUnit2.isMainOutput,
"Extra deferred constant: ${value2.toStructuredText()}");
}, elementToString: (a) {
OutputUnit o1 = compilerNormal.deferredLoadTask.outputUnitForConstant(a);
OutputUnit o2 =
compilerDeserialized.deferredLoadTask.outputUnitForConstant(a);
return '${a.toStructuredText()} -> ${o1}/${o2}';
});
}
void checkElements(
Compiler compiler1, Compiler compiler2, Element element1, Element element2,
{bool verbose: false}) {
if (element1.isAbstract) return;
if (element1.isFunction ||
element1.isConstructor ||
(element1.isField && element1.isInstanceMember)) {
ClosureRepresentationInfo closureData1 = compiler1
.backendStrategy.closureDataLookup
.getClosureInfoForMember(element1 as MemberElement);
ClosureRepresentationInfo closureData2 = compiler2
.backendStrategy.closureDataLookup
.getClosureInfoForMember(element2 as MemberElement);
checkElementIdentities(
closureData1,
closureData2,
'$element1.closureEntity',
closureData1.closureEntity,
closureData2.closureEntity);
checkElementIdentities(
closureData1,
closureData2,
'$element1.closureClassEntity',
closureData1.closureClassEntity,
closureData2.closureClassEntity);
checkElementIdentities(closureData1, closureData2, '$element1.callMethod',
closureData1.callMethod, closureData2.callMethod);
check(closureData1, closureData2, '$element1.thisLocal',
closureData1.thisLocal, closureData2.thisLocal, areLocalsEquivalent);
checkElementListIdentities(
closureData1,
closureData2,
"$element1.createdFieldEntities",
closureData1.createdFieldEntities,
closureData2.createdFieldEntities);
check(
closureData1,
closureData2,
'$element1.thisFieldEntity',
closureData1.thisFieldEntity,
closureData2.thisFieldEntity,
areLocalsEquivalent);
if (element1 is MemberElement && element2 is MemberElement) {
MemberElement member1 = element1.implementation;
MemberElement member2 = element2.implementation;
checkSets(member1.nestedClosures, member2.nestedClosures,
"$member1.nestedClosures", areElementsEquivalent, verbose: verbose,
onSameElement: (a, b) {
LocalFunctionElement localFunction1 = a.expression;
LocalFunctionElement localFunction2 = b.expression;
checkElementIdentities(localFunction1, localFunction2, 'enclosingClass',
localFunction1.enclosingClass, localFunction2.enclosingClass);
testResolvedAstEquivalence(localFunction1.resolvedAst,
localFunction2.resolvedAst, const CheckStrategy());
});
}
}
JavaScriptBackend backend1 = compiler1.backend;
JavaScriptBackend backend2 = compiler2.backend;
if (element1 is MethodElement && element2 is MethodElement) {
Expect.equals(
backend1.inlineCache.getCurrentCacheDecisionForTesting(element1),
backend2.inlineCache.getCurrentCacheDecisionForTesting(element2),
"Inline cache decision mismatch for $element1 vs $element2");
}
checkElementOutputUnits(compiler1, compiler2, element1, element2);
}
bool areLocalsEquivalent(LocalVariable a, LocalVariable b) {
if (a == b) return true;
if (a == null || b == null) return false;
if (a is Element) {
return b is Element && areElementsEquivalent(a as Element, b as Element);
} else {
return a.runtimeType == b.runtimeType &&
areElementsEquivalent(a.executableContext, b.executableContext);
}
}
bool areCapturedVariablesEquivalent(FieldEntity a, FieldEntity b) {
if (a == b) return true;
if (a == null || b == null) return false;
if (a is ClosureFieldElement && b is ClosureFieldElement) {
return areElementsEquivalent(a.closureClass, b.closureClass) &&
areLocalsEquivalent(a.local, b.local);
} else if (a is BoxFieldElement && b is BoxFieldElement) {
return areElementsEquivalent(a.variableElement, b.variableElement) &&
areLocalsEquivalent(a.box, b.box);
}
return false;
}
bool areCapturedScopesEquivalent(CapturedScope a, CapturedScope b) {
if (a == b) return true;
if (a == null || b == null) return false;
if (!areLocalsEquivalent(a.context, b.context)) {
return false;
}
if (!areLocalsEquivalent(a.thisLocal, b.thisLocal)) {
return false;
}
var aBoxed = {};
a.forEachBoxedVariable((k, v) => aBoxed[k] = v);
var bBoxed = {};
b.forEachBoxedVariable((k, v) => bBoxed[k] = v);
checkMaps(aBoxed, bBoxed, 'CapturedScope.boxedVariables', areLocalsEquivalent,
areElementsEquivalent);
return true;
}
String nodeToString(Node node) {
String text = '$node';
if (text.length > 40) {
return '(${node.runtimeType}) ${text.substring(0, 37)}...';
}
return '(${node.runtimeType}) $text';
}
void checkElementOutputUnits(Compiler compiler1, Compiler compiler2,
Element element1, Element element2) {
OutputUnit outputUnit1 =
compiler1.deferredLoadTask.getOutputUnitForElementForTesting(element1);
OutputUnit outputUnit2 =
compiler2.deferredLoadTask.getOutputUnitForElementForTesting(element2);
checkOutputUnits(compiler1, compiler2, outputUnit1, outputUnit2,
'for $element1 vs $element2');
}
void checkOutputUnits(Compiler compiler1, Compiler compiler2,
OutputUnit outputUnit1, OutputUnit outputUnit2, String message) {
if (outputUnit1 == null && outputUnit2 == null) return;
check(outputUnit1, outputUnit2, 'OutputUnit.isMainOutput $message',
outputUnit1.isMainOutput, outputUnit2.isMainOutput);
checkSetEquivalence(
outputUnit1,
outputUnit2,
'OutputUnit.imports $message',
compiler1.deferredLoadTask.getImportNames(outputUnit1),
compiler2.deferredLoadTask.getImportNames(outputUnit2),
(a, b) => areElementsEquivalent(a.declaration, b.declaration));
}