Index: tests/compiler/dart2js/serialization_helper.dart |
diff --git a/tests/compiler/dart2js/serialization_helper.dart b/tests/compiler/dart2js/serialization_helper.dart |
deleted file mode 100644 |
index 2d1ea1fd6884e5d963d9f8e9cd770b0ee9962878..0000000000000000000000000000000000000000 |
--- a/tests/compiler/dart2js/serialization_helper.dart |
+++ /dev/null |
@@ -1,349 +0,0 @@ |
-// 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. |
- |
-library dart2js.serialization_helper; |
- |
-import 'dart:async'; |
-import 'dart:io'; |
- |
-import 'package:compiler/src/commandline_options.dart'; |
-import 'package:compiler/src/common.dart'; |
-import 'package:compiler/src/common/backend_api.dart'; |
-import 'package:compiler/src/common/names.dart'; |
-import 'package:compiler/src/common/resolution.dart'; |
-import 'package:compiler/src/compiler.dart'; |
-import 'package:compiler/src/elements/elements.dart'; |
-import 'package:compiler/src/io/source_file.dart'; |
-import 'package:compiler/src/scanner/scanner.dart'; |
-import 'package:compiler/src/script.dart'; |
-import 'package:compiler/src/serialization/impact_serialization.dart'; |
-import 'package:compiler/src/serialization/json_serializer.dart'; |
-import 'package:compiler/src/serialization/modelz.dart'; |
-import 'package:compiler/src/serialization/resolved_ast_serialization.dart'; |
-import 'package:compiler/src/serialization/serialization.dart'; |
-import 'package:compiler/src/serialization/task.dart'; |
-import 'package:compiler/src/tokens/token.dart'; |
-import 'package:compiler/src/universe/call_structure.dart'; |
-import 'package:compiler/src/universe/world_impact.dart'; |
-import 'package:compiler/src/universe/use.dart'; |
- |
-import 'memory_compiler.dart'; |
- |
-class Arguments { |
- final String filename; |
- final bool loadSerializedData; |
- final bool saveSerializedData; |
- final String serializedDataFileName; |
- final bool verbose; |
- |
- const Arguments({ |
- this.filename, |
- this.loadSerializedData: false, |
- this.saveSerializedData: false, |
- this.serializedDataFileName: 'out.data', |
- this.verbose: false}); |
- |
- factory Arguments.from(List<String> arguments) { |
- String filename; |
- for (String arg in arguments) { |
- if (!arg.startsWith('-')) { |
- filename = arg; |
- } |
- } |
- bool verbose = arguments.contains('-v'); |
- bool loadSerializedData = arguments.contains('-l'); |
- bool saveSerializedData = arguments.contains('-s'); |
- return new Arguments( |
- filename: filename, |
- verbose: verbose, |
- loadSerializedData: loadSerializedData, |
- saveSerializedData: saveSerializedData); |
- } |
-} |
- |
- |
-Future<String> serializeDartCore( |
- {Arguments arguments: const Arguments(), |
- bool serializeResolvedAst: false}) async { |
- print('------------------------------------------------------------------'); |
- print('serialize dart:core'); |
- print('------------------------------------------------------------------'); |
- String serializedData; |
- if (arguments.loadSerializedData) { |
- File file = new File(arguments.serializedDataFileName); |
- if (file.existsSync()) { |
- print('Loading data from $file'); |
- serializedData = file.readAsStringSync(); |
- } |
- } |
- if (serializedData == null) { |
- Compiler compiler = compilerFor( |
- options: [Flags.analyzeAll]); |
- compiler.serialization.supportSerialization = true; |
- await compiler.run(Uris.dart_core); |
- serializedData = serialize( |
- compiler, |
- compiler.libraryLoader.libraries, |
- serializeResolvedAst: serializeResolvedAst) |
- .toText(const JsonSerializationEncoder()); |
- if (arguments.saveSerializedData) { |
- File file = new File(arguments.serializedDataFileName); |
- print('Saving data to $file'); |
- file.writeAsStringSync(serializedData); |
- } |
- } |
- return serializedData; |
-} |
- |
-Serializer serialize( |
- Compiler compiler, |
- Iterable<LibraryElement> libraries, |
- {bool serializeResolvedAst: false}) { |
- assert(compiler.serialization.supportSerialization); |
- |
- Serializer serializer = new Serializer(); |
- serializer.plugins.add(compiler.backend.serialization.serializer); |
- serializer.plugins.add(new ResolutionImpactSerializer(compiler.resolution)); |
- if (serializeResolvedAst) { |
- serializer.plugins.add( |
- new ResolvedAstSerializerPlugin(compiler.resolution, compiler.backend)); |
- } |
- |
- for (LibraryElement library in libraries) { |
- serializer.serialize(library); |
- } |
- return serializer; |
-} |
- |
-void deserialize(Compiler compiler, |
- String serializedData, |
- {bool deserializeResolvedAst: false}) { |
- Deserializer deserializer = new Deserializer.fromText( |
- new DeserializationContext(), |
- serializedData, |
- const JsonSerializationDecoder()); |
- deserializer.plugins.add(compiler.backend.serialization.deserializer); |
- compiler.serialization.deserializer = |
- new _DeserializerSystem( |
- compiler, |
- deserializer, |
- compiler.backend.impactTransformer, |
- deserializeResolvedAst: deserializeResolvedAst); |
-} |
- |
- |
-const String WORLD_IMPACT_TAG = 'worldImpact'; |
- |
-class ResolutionImpactSerializer extends SerializerPlugin { |
- final Resolution resolution; |
- |
- ResolutionImpactSerializer(this.resolution); |
- |
- @override |
- void onElement(Element element, ObjectEncoder createEncoder(String tag)) { |
- if (resolution.hasBeenResolved(element)) { |
- ResolutionImpact impact = resolution.getResolutionImpact(element); |
- ObjectEncoder encoder = createEncoder(WORLD_IMPACT_TAG); |
- new ImpactSerializer(element, encoder).serialize(impact); |
- } |
- } |
-} |
- |
-class ResolutionImpactDeserializer extends DeserializerPlugin { |
- Map<Element, ResolutionImpact> impactMap = <Element, ResolutionImpact>{}; |
- |
- @override |
- void onElement(Element element, ObjectDecoder getDecoder(String tag)) { |
- ObjectDecoder decoder = getDecoder(WORLD_IMPACT_TAG); |
- if (decoder != null) { |
- impactMap[element] = |
- ImpactDeserializer.deserializeImpact(element, decoder); |
- } |
- } |
-} |
- |
-class _DeserializerSystem extends DeserializerSystem { |
- final Compiler _compiler; |
- final Deserializer _deserializer; |
- final List<LibraryElement> deserializedLibraries = <LibraryElement>[]; |
- final ResolutionImpactDeserializer _resolutionImpactDeserializer = |
- new ResolutionImpactDeserializer(); |
- final ResolvedAstDeserializerPlugin _resolvedAstDeserializer; |
- final ImpactTransformer _impactTransformer; |
- final bool _deserializeResolvedAst; |
- |
- _DeserializerSystem( |
- Compiler compiler, |
- this._deserializer, |
- this._impactTransformer, |
- {bool deserializeResolvedAst: false}) |
- : this._compiler = compiler, |
- this._deserializeResolvedAst = deserializeResolvedAst, |
- this._resolvedAstDeserializer = deserializeResolvedAst |
- ? new ResolvedAstDeserializerPlugin( |
- compiler.parsingContext, compiler.backend) : null { |
- _deserializer.plugins.add(_resolutionImpactDeserializer); |
- if (_deserializeResolvedAst) { |
- _deserializer.plugins.add(_resolvedAstDeserializer); |
- } |
- } |
- |
- @override |
- Future<LibraryElement> readLibrary(Uri resolvedUri) { |
- LibraryElement library = _deserializer.lookupLibrary(resolvedUri); |
- if (library != null) { |
- deserializedLibraries.add(library); |
- if (_deserializeResolvedAst) { |
- return Future.forEach(library.compilationUnits, |
- (CompilationUnitElement compilationUnit) { |
- ScriptZ script = compilationUnit.script; |
- return _compiler.readScript(script.readableUri) |
- .then((Script newScript) { |
- script.file = newScript.file; |
- _resolvedAstDeserializer.sourceFiles[script.resourceUri] = |
- newScript.file; |
- }); |
- }).then((_) => library); |
- } |
- } |
- return new Future<LibraryElement>.value(library); |
- } |
- |
- @override |
- bool hasResolvedAst(Element element) { |
- if (_resolvedAstDeserializer != null) { |
- return _resolvedAstDeserializer.hasResolvedAst(element); |
- } |
- return false; |
- } |
- |
- @override |
- ResolvedAst getResolvedAst(Element element) { |
- if (_resolvedAstDeserializer != null) { |
- return _resolvedAstDeserializer.getResolvedAst(element); |
- } |
- return null; |
- } |
- |
- @override |
- bool hasResolutionImpact(Element element) { |
- if (element.isConstructor && |
- element.enclosingClass.isUnnamedMixinApplication) { |
- return true; |
- } |
- return _resolutionImpactDeserializer.impactMap.containsKey(element); |
- } |
- |
- @override |
- ResolutionImpact getResolutionImpact(Element element) { |
- if (element.isConstructor && |
- element.enclosingClass.isUnnamedMixinApplication) { |
- ClassElement superclass = element.enclosingClass.superclass; |
- ConstructorElement superclassConstructor = |
- superclass.lookupConstructor(element.name); |
- assert(invariant(element, superclassConstructor != null, |
- message: "Superclass constructor '${element.name}' called from " |
- "${element} not found in ${superclass}.")); |
- // TODO(johnniwinther): Compute callStructure. Currently not used. |
- CallStructure callStructure; |
- return _resolutionImpactDeserializer.impactMap.putIfAbsent(element, () { |
- return new DeserializedResolutionImpact( |
- staticUses: <StaticUse>[new StaticUse.superConstructorInvoke( |
- superclassConstructor, callStructure)]); |
- }); |
- } |
- return _resolutionImpactDeserializer.impactMap[element]; |
- } |
- |
- @override |
- WorldImpact computeWorldImpact(Element element) { |
- ResolutionImpact resolutionImpact = getResolutionImpact(element); |
- assert(invariant(element, resolutionImpact != null, |
- message: 'No impact found for $element (${element.library})')); |
- return _impactTransformer.transformResolutionImpact(resolutionImpact); |
- } |
- |
- @override |
- bool isDeserialized(Element element) { |
- return deserializedLibraries.contains(element.library); |
- } |
-} |
- |
-const String RESOLVED_AST_TAG = 'resolvedAst'; |
- |
-class ResolvedAstSerializerPlugin extends SerializerPlugin { |
- final Resolution resolution; |
- final Backend backend; |
- |
- ResolvedAstSerializerPlugin(this.resolution, this.backend); |
- |
- @override |
- void onElement(Element element, ObjectEncoder createEncoder(String tag)) { |
- assert(invariant(element, element.isDeclaration, |
- message: "Element $element must be the declaration")); |
- if (element is MemberElement) { |
- assert(invariant(element, resolution.hasResolvedAst(element), |
- message: "Element $element must have a resolved ast")); |
- ResolvedAst resolvedAst = resolution.getResolvedAst(element); |
- ObjectEncoder objectEncoder = createEncoder(RESOLVED_AST_TAG); |
- new ResolvedAstSerializer( |
- objectEncoder, |
- resolvedAst, |
- backend.serialization.serializer).serialize(); |
- } |
- } |
-} |
- |
-class ResolvedAstDeserializerPlugin extends DeserializerPlugin { |
- final ParsingContext parsingContext; |
- final Backend backend; |
- final Map<Uri, SourceFile> sourceFiles = <Uri, SourceFile>{}; |
- |
- Map<Element, ResolvedAst> _resolvedAstMap = <Element, ResolvedAst>{}; |
- Map<Element, ObjectDecoder> _decoderMap = <Element, ObjectDecoder>{}; |
- Map<Uri, Token> beginTokenMap = <Uri, Token>{}; |
- |
- ResolvedAstDeserializerPlugin(this.parsingContext, this.backend); |
- |
- bool hasResolvedAst(Element element) { |
- return _resolvedAstMap.containsKey(element) || |
- _decoderMap.containsKey(element); |
- } |
- |
- ResolvedAst getResolvedAst(Element element) { |
- ResolvedAst resolvedAst = _resolvedAstMap[element]; |
- if (resolvedAst == null) { |
- ObjectDecoder decoder = _decoderMap[element]; |
- if (decoder != null) { |
- resolvedAst = _resolvedAstMap[element] = |
- ResolvedAstDeserializer.deserialize( |
- element, decoder, parsingContext, findToken, |
- backend.serialization.deserializer); |
- _decoderMap.remove(element); |
- } |
- } |
- return resolvedAst; |
- } |
- |
- Token findToken(Uri uri, int offset) { |
- Token beginToken = beginTokenMap.putIfAbsent(uri, () { |
- SourceFile sourceFile = sourceFiles[uri]; |
- if (sourceFile == null) { |
- throw 'No source file found for $uri in:\n ' |
- '${sourceFiles.keys.join('\n ')}'; |
- } |
- return new Scanner(sourceFile).tokenize(); |
- }); |
- return ResolvedAstDeserializer.findTokenInStream(beginToken, offset); |
- } |
- |
- @override |
- void onElement(Element element, ObjectDecoder getDecoder(String tag)) { |
- ObjectDecoder decoder = getDecoder(RESOLVED_AST_TAG); |
- if (decoder != null) { |
- _decoderMap[element] = decoder; |
- } |
- } |
-} |
- |