| // Copyright (c) 2012, 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.common.codegen; | |
| import 'package:js_ast/src/precedence.dart' as js show PRIMARY; | |
| import '../common.dart'; | |
| import '../common_elements.dart'; | |
| import '../constants/values.dart'; | |
| import '../deferred_load.dart'; | |
| import '../elements/entities.dart'; | |
| import '../elements/types.dart' show DartType, InterfaceType; | |
| import '../inferrer/abstract_value_domain.dart'; | |
| import '../inferrer/types.dart'; | |
| import '../io/source_information.dart'; | |
| import '../js/js.dart' as js; | |
| import '../js_backend/backend.dart'; | |
| import '../js_backend/namer.dart'; | |
| import '../js_backend/deferred_holder_expression.dart' | |
| show DeferredHolderExpression; | |
| import '../js_backend/string_reference.dart' show StringReference; | |
| import '../js_backend/type_reference.dart' show TypeReference; | |
| import '../js_emitter/code_emitter_task.dart' show Emitter; | |
| import '../js_model/type_recipe.dart' show TypeRecipe; | |
| import '../native/behavior.dart'; | |
| import '../serialization/serialization.dart'; | |
| import '../ssa/ssa.dart'; | |
| import '../universe/feature.dart'; | |
| import '../universe/selector.dart'; | |
| import '../universe/use.dart' show ConstantUse, DynamicUse, StaticUse, TypeUse; | |
| import '../universe/world_impact.dart' | |
| show WorldImpact, WorldImpactBuilderImpl, WorldImpactVisitor; | |
| import '../util/enumset.dart'; | |
| import '../util/util.dart'; | |
| import '../world.dart'; | |
| class CodegenImpact extends WorldImpact { | |
| const CodegenImpact(); | |
| factory CodegenImpact.readFromDataSource(DataSource source) = | |
| _CodegenImpact.readFromDataSource; | |
| void writeToDataSink(DataSink sink) { | |
| throw new UnsupportedError('CodegenImpact.writeToDataSink'); | |
| } | |
| Iterable<Pair<DartType, DartType>> get typeVariableBoundsSubtypeChecks { | |
| return const <Pair<DartType, DartType>>[]; | |
| } | |
| Iterable<String> get constSymbols => const <String>[]; | |
| Iterable<Set<ClassEntity>> get specializedGetInterceptors { | |
| return const <Set<ClassEntity>>[]; | |
| } | |
| bool get usesInterceptor => false; | |
| Iterable<AsyncMarker> get asyncMarkers => const <AsyncMarker>[]; | |
| Iterable<GenericInstantiation> get genericInstantiations => | |
| const <GenericInstantiation>[]; | |
| Iterable<NativeBehavior> get nativeBehaviors => const []; | |
| Iterable<FunctionEntity> get nativeMethods => const []; | |
| Iterable<Selector> get oneShotInterceptors => const []; | |
| } | |
| class _CodegenImpact extends WorldImpactBuilderImpl implements CodegenImpact { | |
| static const String tag = 'codegen-impact'; | |
| @override | |
| final MemberEntity member; | |
| Set<Pair<DartType, DartType>> _typeVariableBoundsSubtypeChecks; | |
| Set<String> _constSymbols; | |
| List<Set<ClassEntity>> _specializedGetInterceptors; | |
| bool _usesInterceptor = false; | |
| EnumSet<AsyncMarker> _asyncMarkers; | |
| Set<GenericInstantiation> _genericInstantiations; | |
| List<NativeBehavior> _nativeBehaviors; | |
| Set<FunctionEntity> _nativeMethods; | |
| Set<Selector> _oneShotInterceptors; | |
| _CodegenImpact(this.member); | |
| _CodegenImpact.internal( | |
| this.member, | |
| Set<DynamicUse> dynamicUses, | |
| Set<StaticUse> staticUses, | |
| Set<TypeUse> typeUses, | |
| Set<ConstantUse> constantUses, | |
| this._typeVariableBoundsSubtypeChecks, | |
| this._constSymbols, | |
| this._specializedGetInterceptors, | |
| this._usesInterceptor, | |
| this._asyncMarkers, | |
| this._genericInstantiations, | |
| this._nativeBehaviors, | |
| this._nativeMethods, | |
| this._oneShotInterceptors) | |
| : super.internal(dynamicUses, staticUses, typeUses, constantUses); | |
| factory _CodegenImpact.readFromDataSource(DataSource source) { | |
| source.begin(tag); | |
| MemberEntity member = source.readMember(); | |
| Set<DynamicUse> dynamicUses = source | |
| .readList(() => DynamicUse.readFromDataSource(source), | |
| emptyAsNull: true) | |
| ?.toSet(); | |
| Set<StaticUse> staticUses = source | |
| .readList(() => StaticUse.readFromDataSource(source), emptyAsNull: true) | |
| ?.toSet(); | |
| Set<TypeUse> typeUses = source | |
| .readList(() => TypeUse.readFromDataSource(source), emptyAsNull: true) | |
| ?.toSet(); | |
| Set<ConstantUse> constantUses = source | |
| .readList(() => ConstantUse.readFromDataSource(source), | |
| emptyAsNull: true) | |
| ?.toSet(); | |
| Set<Pair<DartType, DartType>> typeVariableBoundsSubtypeChecks = | |
| source.readList(() { | |
| return new Pair(source.readDartType(), source.readDartType()); | |
| }, emptyAsNull: true)?.toSet(); | |
| Set<String> constSymbols = source.readStrings(emptyAsNull: true)?.toSet(); | |
| List<Set<ClassEntity>> specializedGetInterceptors = source.readList(() { | |
| return source.readClasses().toSet(); | |
| }, emptyAsNull: true); | |
| bool usesInterceptor = source.readBool(); | |
| int asyncMarkersValue = source.readIntOrNull(); | |
| EnumSet<AsyncMarker> asyncMarkers = asyncMarkersValue != null | |
| ? new EnumSet.fromValue(asyncMarkersValue) | |
| : null; | |
| Set<GenericInstantiation> genericInstantiations = source | |
| .readList(() => GenericInstantiation.readFromDataSource(source), | |
| emptyAsNull: true) | |
| ?.toSet(); | |
| List<NativeBehavior> nativeBehaviors = source.readList( | |
| () => NativeBehavior.readFromDataSource(source), | |
| emptyAsNull: true); | |
| Set<FunctionEntity> nativeMethods = | |
| source.readMembers<FunctionEntity>(emptyAsNull: true)?.toSet(); | |
| Set<Selector> oneShotInterceptors = source | |
| .readList(() => Selector.readFromDataSource(source), emptyAsNull: true) | |
| ?.toSet(); | |
| source.end(tag); | |
| return new _CodegenImpact.internal( | |
| member, | |
| dynamicUses, | |
| staticUses, | |
| typeUses, | |
| constantUses, | |
| typeVariableBoundsSubtypeChecks, | |
| constSymbols, | |
| specializedGetInterceptors, | |
| usesInterceptor, | |
| asyncMarkers, | |
| genericInstantiations, | |
| nativeBehaviors, | |
| nativeMethods, | |
| oneShotInterceptors); | |
| } | |
| @override | |
| void writeToDataSink(DataSink sink) { | |
| sink.begin(tag); | |
| sink.writeMember(member); | |
| sink.writeList(dynamicUses, (DynamicUse use) => use.writeToDataSink(sink), | |
| allowNull: true); | |
| sink.writeList(staticUses, (StaticUse use) => use.writeToDataSink(sink), | |
| allowNull: true); | |
| sink.writeList(typeUses, (TypeUse use) => use.writeToDataSink(sink), | |
| allowNull: true); | |
| sink.writeList(constantUses, (ConstantUse use) => use.writeToDataSink(sink), | |
| allowNull: true); | |
| sink.writeList<Pair<DartType, DartType>>(_typeVariableBoundsSubtypeChecks, | |
| (pair) { | |
| sink.writeDartType(pair.a); | |
| sink.writeDartType(pair.b); | |
| }, allowNull: true); | |
| sink.writeStrings(_constSymbols, allowNull: true); | |
| sink.writeList(_specializedGetInterceptors, sink.writeClasses, | |
| allowNull: true); | |
| sink.writeBool(_usesInterceptor); | |
| sink.writeIntOrNull(_asyncMarkers?.value); | |
| sink.writeList( | |
| _genericInstantiations, | |
| (GenericInstantiation instantiation) => | |
| instantiation.writeToDataSink(sink), | |
| allowNull: true); | |
| sink.writeList(_nativeBehaviors, | |
| (NativeBehavior behavior) => behavior.writeToDataSink(sink), | |
| allowNull: true); | |
| sink.writeMembers(_nativeMethods, allowNull: true); | |
| sink.writeList(_oneShotInterceptors, | |
| (Selector selector) => selector.writeToDataSink(sink), | |
| allowNull: true); | |
| sink.end(tag); | |
| } | |
| @override | |
| void apply(WorldImpactVisitor visitor) { | |
| staticUses.forEach((StaticUse use) => visitor.visitStaticUse(member, use)); | |
| dynamicUses.forEach((DynamicUse use) => visitor.visitDynamicUse); | |
| typeUses.forEach((TypeUse use) => visitor.visitTypeUse(member, use)); | |
| constantUses | |
| .forEach((ConstantUse use) => visitor.visitConstantUse(member, use)); | |
| } | |
| void registerTypeVariableBoundsSubtypeCheck( | |
| DartType subtype, DartType supertype) { | |
| _typeVariableBoundsSubtypeChecks ??= {}; | |
| _typeVariableBoundsSubtypeChecks | |
| .add(new Pair<DartType, DartType>(subtype, supertype)); | |
| } | |
| @override | |
| Iterable<Pair<DartType, DartType>> get typeVariableBoundsSubtypeChecks { | |
| return _typeVariableBoundsSubtypeChecks != null | |
| ? _typeVariableBoundsSubtypeChecks | |
| : const <Pair<DartType, DartType>>[]; | |
| } | |
| void registerConstSymbol(String name) { | |
| _constSymbols ??= {}; | |
| _constSymbols.add(name); | |
| } | |
| @override | |
| Iterable<String> get constSymbols { | |
| return _constSymbols != null ? _constSymbols : const <String>[]; | |
| } | |
| void registerSpecializedGetInterceptor(Set<ClassEntity> classes) { | |
| _specializedGetInterceptors ??= <Set<ClassEntity>>[]; | |
| _specializedGetInterceptors.add(classes); | |
| } | |
| @override | |
| Iterable<Set<ClassEntity>> get specializedGetInterceptors { | |
| return _specializedGetInterceptors != null | |
| ? _specializedGetInterceptors | |
| : const <Set<ClassEntity>>[]; | |
| } | |
| void registerUseInterceptor() { | |
| _usesInterceptor = true; | |
| } | |
| @override | |
| bool get usesInterceptor => _usesInterceptor; | |
| void registerAsyncMarker(AsyncMarker asyncMarker) { | |
| _asyncMarkers ??= new EnumSet<AsyncMarker>(); | |
| _asyncMarkers.add(asyncMarker); | |
| } | |
| @override | |
| Iterable<AsyncMarker> get asyncMarkers { | |
| return _asyncMarkers != null | |
| ? _asyncMarkers.iterable(AsyncMarker.values) | |
| : const <AsyncMarker>[]; | |
| } | |
| void registerGenericInstantiation(GenericInstantiation instantiation) { | |
| _genericInstantiations ??= {}; | |
| _genericInstantiations.add(instantiation); | |
| } | |
| @override | |
| Iterable<GenericInstantiation> get genericInstantiations { | |
| return _genericInstantiations ?? const <GenericInstantiation>[]; | |
| } | |
| void registerNativeBehavior(NativeBehavior nativeBehavior) { | |
| _nativeBehaviors ??= []; | |
| _nativeBehaviors.add(nativeBehavior); | |
| } | |
| @override | |
| Iterable<NativeBehavior> get nativeBehaviors { | |
| return _nativeBehaviors ?? const <NativeBehavior>[]; | |
| } | |
| void registerNativeMethod(FunctionEntity function) { | |
| _nativeMethods ??= {}; | |
| _nativeMethods.add(function); | |
| } | |
| @override | |
| Iterable<FunctionEntity> get nativeMethods { | |
| return _nativeMethods ?? const []; | |
| } | |
| void registerOneShotInterceptor(Selector selector) { | |
| _oneShotInterceptors ??= {}; | |
| _oneShotInterceptors.add(selector); | |
| } | |
| @override | |
| Iterable<Selector> get oneShotInterceptors { | |
| return _oneShotInterceptors ?? const []; | |
| } | |
| @override | |
| String toString() { | |
| StringBuffer sb = new StringBuffer(); | |
| sb.write('CodegenImpact:'); | |
| WorldImpact.printOn(sb, this); | |
| void add(String title, Iterable iterable) { | |
| if (iterable.isNotEmpty) { | |
| sb.write('\n $title:'); | |
| iterable.forEach((e) => sb.write('\n $e')); | |
| } | |
| } | |
| add('typeVariableBoundsSubtypeChecks', typeVariableBoundsSubtypeChecks); | |
| add('constSymbols', constSymbols); | |
| add('specializedGetInterceptors', specializedGetInterceptors); | |
| if (usesInterceptor) { | |
| sb.write('\n usesInterceptor: true'); | |
| } | |
| add('asyncMarkers', asyncMarkers); | |
| add('genericInstantiations', genericInstantiations); | |
| add('nativeBehaviors', nativeBehaviors); | |
| add('nativeMethods', nativeMethods); | |
| add('oneShotInterceptors', oneShotInterceptors); | |
| return sb.toString(); | |
| } | |
| } | |
| // TODO(johnniwinther): Split this class into interface and implementation. | |
| // TODO(johnniwinther): Move this implementation to the JS backend. | |
| class CodegenRegistry { | |
| final ElementEnvironment _elementEnvironment; | |
| final MemberEntity _currentElement; | |
| final _CodegenImpact _worldImpact; | |
| List<ModularName> _names; | |
| List<ModularExpression> _expressions; | |
| CodegenRegistry(this._elementEnvironment, this._currentElement) | |
| : this._worldImpact = new _CodegenImpact(_currentElement); | |
| @override | |
| String toString() => 'CodegenRegistry for $_currentElement'; | |
| @deprecated | |
| void registerInstantiatedClass(ClassEntity element) { | |
| registerInstantiation(_elementEnvironment.getRawType(element)); | |
| } | |
| void registerStaticUse(StaticUse staticUse) { | |
| _worldImpact.registerStaticUse(staticUse); | |
| } | |
| void registerDynamicUse(DynamicUse dynamicUse) { | |
| _worldImpact.registerDynamicUse(dynamicUse); | |
| } | |
| void registerTypeUse(TypeUse typeUse) { | |
| _worldImpact.registerTypeUse(typeUse); | |
| } | |
| void registerConstantUse(ConstantUse constantUse) { | |
| _worldImpact.registerConstantUse(constantUse); | |
| } | |
| void registerTypeVariableBoundsSubtypeCheck( | |
| DartType subtype, DartType supertype) { | |
| _worldImpact.registerTypeVariableBoundsSubtypeCheck(subtype, supertype); | |
| } | |
| void registerInstantiatedClosure(FunctionEntity element) { | |
| _worldImpact.registerStaticUse(new StaticUse.callMethod(element)); | |
| } | |
| void registerConstSymbol(String name) { | |
| _worldImpact.registerConstSymbol(name); | |
| } | |
| void registerSpecializedGetInterceptor(Set<ClassEntity> classes) { | |
| _worldImpact.registerSpecializedGetInterceptor(classes); | |
| } | |
| void registerOneShotInterceptor(Selector selector) { | |
| _worldImpact.registerOneShotInterceptor(selector); | |
| } | |
| void registerUseInterceptor() { | |
| _worldImpact.registerUseInterceptor(); | |
| } | |
| void registerInstantiation(InterfaceType type) { | |
| registerTypeUse(new TypeUse.instantiation(type)); | |
| } | |
| void registerAsyncMarker(AsyncMarker asyncMarker) { | |
| _worldImpact.registerAsyncMarker(asyncMarker); | |
| } | |
| void registerGenericInstantiation(GenericInstantiation instantiation) { | |
| _worldImpact.registerGenericInstantiation(instantiation); | |
| } | |
| void registerNativeBehavior(NativeBehavior nativeBehavior) { | |
| _worldImpact.registerNativeBehavior(nativeBehavior); | |
| } | |
| void registerNativeMethod(FunctionEntity function) { | |
| _worldImpact.registerNativeMethod(function); | |
| } | |
| void registerModularName(ModularName name) { | |
| _names ??= []; | |
| _names.add(name); | |
| } | |
| void registerModularExpression(ModularExpression expression) { | |
| _expressions ??= []; | |
| _expressions.add(expression); | |
| } | |
| CodegenResult close(js.Fun code) { | |
| return new CodegenResult( | |
| code, _worldImpact, _names ?? const [], _expressions ?? const []); | |
| } | |
| } | |
| /// Interface for reading the code generation results for all [MemberEntity]s. | |
| abstract class CodegenResults { | |
| GlobalTypeInferenceResults get globalTypeInferenceResults; | |
| CodegenInputs get codegenInputs; | |
| CodegenResult getCodegenResults(MemberEntity member); | |
| } | |
| /// Code generation results computed on-demand. | |
| /// | |
| /// This is used in the non-modular codegen enqueuer driving code generation. | |
| class OnDemandCodegenResults extends CodegenResults { | |
| @override | |
| final GlobalTypeInferenceResults globalTypeInferenceResults; | |
| @override | |
| final CodegenInputs codegenInputs; | |
| final SsaFunctionCompiler _functionCompiler; | |
| OnDemandCodegenResults(this.globalTypeInferenceResults, this.codegenInputs, | |
| this._functionCompiler); | |
| @override | |
| CodegenResult getCodegenResults(MemberEntity member) { | |
| return _functionCompiler.compile(member); | |
| } | |
| } | |
| /// Deserialized code generation results. | |
| /// | |
| /// This is used for modular code generation. | |
| class DeserializedCodegenResults extends CodegenResults { | |
| @override | |
| final GlobalTypeInferenceResults globalTypeInferenceResults; | |
| @override | |
| final CodegenInputs codegenInputs; | |
| final Map<MemberEntity, CodegenResult> _map; | |
| DeserializedCodegenResults( | |
| this.globalTypeInferenceResults, this.codegenInputs, this._map); | |
| @override | |
| CodegenResult getCodegenResults(MemberEntity member) { | |
| CodegenResult result = _map[member]; | |
| if (result == null) { | |
| failedAt(member, | |
| "No codegen results from $member (${identityHashCode(member)})."); | |
| } | |
| return result; | |
| } | |
| } | |
| /// The code generation result for a single [MemberEntity]. | |
| class CodegenResult { | |
| static const String tag = 'codegen-result'; | |
| final js.Fun code; | |
| final CodegenImpact impact; | |
| final Iterable<ModularName> modularNames; | |
| final Iterable<ModularExpression> modularExpressions; | |
| CodegenResult(this.code, this.impact, List<ModularName> modularNames, | |
| List<ModularExpression> modularExpressions) | |
| : this.modularNames = | |
| modularNames.isEmpty ? const [] : List.unmodifiable(modularNames), | |
| this.modularExpressions = modularExpressions.isEmpty | |
| ? const [] | |
| : List.unmodifiable(modularExpressions); | |
| /// Reads a [CodegenResult] object from [source]. | |
| /// | |
| /// The [ModularName] and [ModularExpression] nodes read during | |
| /// deserialization are collected in [modularNames] and [modularExpressions] | |
| /// to avoid the need for visiting the [code] node post deserialization. | |
| factory CodegenResult.readFromDataSource( | |
| DataSource source, | |
| List<ModularName> modularNames, | |
| List<ModularExpression> modularExpressions) { | |
| source.begin(tag); | |
| js.Fun code = source.readJsNodeOrNull(); | |
| CodegenImpact impact = CodegenImpact.readFromDataSource(source); | |
| source.end(tag); | |
| return CodegenResult(code, impact, modularNames, modularExpressions); | |
| } | |
| /// Writes the [CodegenResult] object to [sink]. | |
| /// | |
| /// The [modularNames] and [modularExpressions] fields are not directly | |
| /// serializes because these are embedded in the [code] node and collected | |
| /// through this during deserialization. | |
| void writeToDataSink(DataSink sink) { | |
| sink.begin(tag); | |
| sink.writeJsNodeOrNull(code); | |
| impact.writeToDataSink(sink); | |
| sink.end(tag); | |
| } | |
| void applyModularState(Namer namer, Emitter emitter) { | |
| for (ModularName name in modularNames) { | |
| switch (name.kind) { | |
| case ModularNameKind.rtiField: | |
| name.value = namer.rtiFieldJsName; | |
| break; | |
| case ModularNameKind.runtimeTypeName: | |
| name.value = namer.runtimeTypeName(name.data); | |
| break; | |
| case ModularNameKind.className: | |
| name.value = namer.className(name.data); | |
| break; | |
| case ModularNameKind.aliasedSuperMember: | |
| name.value = namer.aliasedSuperMemberPropertyName(name.data); | |
| break; | |
| case ModularNameKind.staticClosure: | |
| name.value = namer.staticClosureName(name.data); | |
| break; | |
| case ModularNameKind.methodProperty: | |
| name.value = namer.methodPropertyName(name.data); | |
| break; | |
| case ModularNameKind.operatorIs: | |
| name.value = namer.operatorIs(name.data); | |
| break; | |
| case ModularNameKind.instanceMethod: | |
| name.value = namer.instanceMethodName(name.data); | |
| break; | |
| case ModularNameKind.instanceField: | |
| name.value = namer.instanceFieldPropertyName(name.data); | |
| break; | |
| case ModularNameKind.invocation: | |
| name.value = namer.invocationName(name.data); | |
| break; | |
| case ModularNameKind.lazyInitializer: | |
| name.value = namer.lazyInitializerName(name.data); | |
| break; | |
| case ModularNameKind.globalPropertyNameForClass: | |
| name.value = namer.globalPropertyNameForClass(name.data); | |
| break; | |
| case ModularNameKind.globalPropertyNameForType: | |
| name.value = namer.globalPropertyNameForType(name.data); | |
| break; | |
| case ModularNameKind.globalPropertyNameForMember: | |
| name.value = namer.globalPropertyNameForMember(name.data); | |
| break; | |
| case ModularNameKind.globalNameForInterfaceTypeVariable: | |
| name.value = namer.globalNameForInterfaceTypeVariable(name.data); | |
| break; | |
| case ModularNameKind.nameForGetInterceptor: | |
| name.value = namer.nameForGetInterceptor(name.set); | |
| break; | |
| case ModularNameKind.nameForOneShotInterceptor: | |
| name.value = namer.nameForOneShotInterceptor(name.data, name.set); | |
| break; | |
| case ModularNameKind.asName: | |
| name.value = namer.asName(name.data); | |
| break; | |
| } | |
| } | |
| for (ModularExpression expression in modularExpressions) { | |
| switch (expression.kind) { | |
| case ModularExpressionKind.constant: | |
| expression.value = emitter | |
| .constantReference(expression.data) | |
| .withSourceInformation(expression.sourceInformation); | |
| break; | |
| case ModularExpressionKind.embeddedGlobalAccess: | |
| expression.value = emitter | |
| .generateEmbeddedGlobalAccess(expression.data) | |
| .withSourceInformation(expression.sourceInformation); | |
| break; | |
| } | |
| } | |
| } | |
| @override | |
| String toString() { | |
| StringBuffer sb = new StringBuffer(); | |
| sb.write('CodegenResult(code='); | |
| sb.write(code != null ? js.DebugPrint(code) : '<null>,'); | |
| sb.write('impact=$impact,'); | |
| sb.write('modularNames=$modularNames,'); | |
| sb.write('modularExpressions=$modularExpressions'); | |
| sb.write(')'); | |
| return sb.toString(); | |
| } | |
| } | |
| enum ModularNameKind { | |
| rtiField, | |
| runtimeTypeName, | |
| className, | |
| aliasedSuperMember, | |
| staticClosure, | |
| methodProperty, | |
| operatorIs, | |
| instanceMethod, | |
| instanceField, | |
| invocation, | |
| lazyInitializer, | |
| globalPropertyNameForClass, | |
| globalPropertyNameForType, | |
| globalPropertyNameForMember, | |
| globalNameForInterfaceTypeVariable, | |
| nameForGetInterceptor, | |
| nameForOneShotInterceptor, | |
| asName, | |
| } | |
| class ModularName extends js.Name implements js.AstContainer { | |
| static const String tag = 'modular-name'; | |
| final ModularNameKind kind; | |
| js.Name _value; | |
| final Object data; | |
| final Set<ClassEntity> set; | |
| ModularName(this.kind, {this.data, this.set}); | |
| factory ModularName.readFromDataSource(DataSource source) { | |
| source.begin(tag); | |
| ModularNameKind kind = source.readEnum(ModularNameKind.values); | |
| Object data; | |
| Set<ClassEntity> set; | |
| switch (kind) { | |
| case ModularNameKind.rtiField: | |
| break; | |
| case ModularNameKind.globalPropertyNameForType: | |
| case ModularNameKind.runtimeTypeName: | |
| case ModularNameKind.className: | |
| case ModularNameKind.operatorIs: | |
| case ModularNameKind.globalPropertyNameForClass: | |
| data = source.readClass(); | |
| break; | |
| case ModularNameKind.aliasedSuperMember: | |
| case ModularNameKind.staticClosure: | |
| case ModularNameKind.methodProperty: | |
| case ModularNameKind.instanceField: | |
| case ModularNameKind.instanceMethod: | |
| case ModularNameKind.lazyInitializer: | |
| case ModularNameKind.globalPropertyNameForMember: | |
| data = source.readMember(); | |
| break; | |
| case ModularNameKind.invocation: | |
| data = Selector.readFromDataSource(source); | |
| break; | |
| case ModularNameKind.globalNameForInterfaceTypeVariable: | |
| data = source.readTypeVariable(); | |
| break; | |
| case ModularNameKind.nameForGetInterceptor: | |
| set = source.readClasses().toSet(); | |
| break; | |
| case ModularNameKind.nameForOneShotInterceptor: | |
| data = Selector.readFromDataSource(source); | |
| set = source.readClasses().toSet(); | |
| break; | |
| case ModularNameKind.asName: | |
| data = source.readString(); | |
| break; | |
| } | |
| source.end(tag); | |
| return new ModularName(kind, data: data, set: set); | |
| } | |
| void writeToDataSink(DataSink sink) { | |
| sink.begin(tag); | |
| sink.writeEnum(kind); | |
| switch (kind) { | |
| case ModularNameKind.rtiField: | |
| break; | |
| case ModularNameKind.globalPropertyNameForType: | |
| case ModularNameKind.runtimeTypeName: | |
| case ModularNameKind.className: | |
| case ModularNameKind.operatorIs: | |
| case ModularNameKind.globalPropertyNameForClass: | |
| sink.writeClass(data); | |
| break; | |
| case ModularNameKind.aliasedSuperMember: | |
| case ModularNameKind.staticClosure: | |
| case ModularNameKind.methodProperty: | |
| case ModularNameKind.instanceField: | |
| case ModularNameKind.instanceMethod: | |
| case ModularNameKind.lazyInitializer: | |
| case ModularNameKind.globalPropertyNameForMember: | |
| sink.writeMember(data); | |
| break; | |
| case ModularNameKind.invocation: | |
| Selector selector = data; | |
| selector.writeToDataSink(sink); | |
| break; | |
| case ModularNameKind.globalNameForInterfaceTypeVariable: | |
| TypeVariableEntity typeVariable = data; | |
| sink.writeTypeVariable(typeVariable); | |
| break; | |
| case ModularNameKind.nameForGetInterceptor: | |
| sink.writeClasses(set); | |
| break; | |
| case ModularNameKind.nameForOneShotInterceptor: | |
| Selector selector = data; | |
| selector.writeToDataSink(sink); | |
| sink.writeClasses(set); | |
| break; | |
| case ModularNameKind.asName: | |
| sink.writeString(data); | |
| break; | |
| } | |
| sink.end(tag); | |
| } | |
| js.Name get value { | |
| assert(_value != null, 'value not set for $this'); | |
| return _value; | |
| } | |
| void set value(js.Name node) { | |
| assert(_value == null); | |
| assert(node != null); | |
| _value = node.withSourceInformation(sourceInformation); | |
| } | |
| @override | |
| String get key { | |
| assert(_value != null); | |
| return _value.key; | |
| } | |
| @override | |
| String get name { | |
| assert(_value != null, 'value not set for $this'); | |
| return _value.name; | |
| } | |
| @override | |
| bool get allowRename { | |
| assert(_value != null, 'value not set for $this'); | |
| return _value.allowRename; | |
| } | |
| @override | |
| int compareTo(js.Name other) { | |
| assert(_value != null, 'value not set for $this'); | |
| return _value.compareTo(other); | |
| } | |
| @override | |
| Iterable<js.Node> get containedNodes { | |
| return _value != null ? [_value] : const []; | |
| } | |
| @override | |
| int get hashCode { | |
| return Hashing.setHash(set, Hashing.objectsHash(kind, data)); | |
| } | |
| @override | |
| bool operator ==(Object other) { | |
| if (identical(this, other)) return true; | |
| return other is ModularName && | |
| kind == other.kind && | |
| data == other.data && | |
| equalSets(set, other.set); | |
| } | |
| @override | |
| String toString() => | |
| 'ModularName(kind=$kind, data=$data, value=${_value?.key})'; | |
| } | |
| enum ModularExpressionKind { | |
| constant, | |
| embeddedGlobalAccess, | |
| } | |
| class ModularExpression extends js.DeferredExpression | |
| implements js.AstContainer { | |
| static const String tag = 'modular-expression'; | |
| final ModularExpressionKind kind; | |
| final Object data; | |
| js.Expression _value; | |
| ModularExpression(this.kind, this.data); | |
| factory ModularExpression.readFromDataSource(DataSource source) { | |
| source.begin(tag); | |
| ModularExpressionKind kind = source.readEnum(ModularExpressionKind.values); | |
| Object data; | |
| switch (kind) { | |
| case ModularExpressionKind.constant: | |
| data = source.readConstant(); | |
| break; | |
| case ModularExpressionKind.embeddedGlobalAccess: | |
| data = source.readString(); | |
| break; | |
| } | |
| source.end(tag); | |
| return new ModularExpression(kind, data); | |
| } | |
| void writeToDataSink(DataSink sink) { | |
| sink.begin(tag); | |
| sink.writeEnum(kind); | |
| switch (kind) { | |
| case ModularExpressionKind.constant: | |
| sink.writeConstant(data); | |
| break; | |
| case ModularExpressionKind.embeddedGlobalAccess: | |
| sink.writeString(data); | |
| break; | |
| } | |
| sink.end(tag); | |
| } | |
| @override | |
| js.Expression get value { | |
| assert(_value != null); | |
| return _value; | |
| } | |
| void set value(js.Expression node) { | |
| assert(_value == null); | |
| assert(node != null); | |
| _value = node.withSourceInformation(sourceInformation); | |
| } | |
| @override | |
| int get precedenceLevel => _value?.precedenceLevel ?? js.PRIMARY; | |
| @override | |
| Iterable<js.Node> get containedNodes { | |
| return _value != null ? [_value] : const []; | |
| } | |
| @override | |
| int get hashCode { | |
| return Hashing.objectsHash(kind, data); | |
| } | |
| @override | |
| bool operator ==(Object other) { | |
| if (identical(this, other)) return true; | |
| return other is ModularExpression && | |
| kind == other.kind && | |
| data == other.data; | |
| } | |
| @override | |
| String toString() { | |
| StringBuffer sb = new StringBuffer(); | |
| sb.write('ModularExpression(kind=$kind,data='); | |
| if (data is ConstantValue) { | |
| sb.write((data as ConstantValue).toStructuredText(null)); | |
| } else { | |
| sb.write(data); | |
| } | |
| sb.write(',value=$_value)'); | |
| return sb.toString(); | |
| } | |
| } | |
| enum JsNodeKind { | |
| comment, | |
| await, | |
| regExpLiteral, | |
| property, | |
| objectInitializer, | |
| arrayHole, | |
| arrayInitializer, | |
| parentheses, | |
| modularName, | |
| asyncName, | |
| stringBackedName, | |
| stringConcatenation, | |
| literalNull, | |
| literalNumber, | |
| literalString, | |
| literalStringFromName, | |
| literalBool, | |
| modularExpression, | |
| function, | |
| namedFunction, | |
| access, | |
| parameter, | |
| variableDeclaration, | |
| thisExpression, | |
| variableUse, | |
| postfix, | |
| prefix, | |
| binary, | |
| callExpression, | |
| newExpression, | |
| conditional, | |
| variableInitialization, | |
| assignment, | |
| variableDeclarationList, | |
| literalExpression, | |
| dartYield, | |
| literalStatement, | |
| labeledStatement, | |
| functionDeclaration, | |
| switchDefault, | |
| switchCase, | |
| switchStatement, | |
| catchClause, | |
| tryStatement, | |
| throwStatement, | |
| returnStatement, | |
| breakStatement, | |
| continueStatement, | |
| doStatement, | |
| whileStatement, | |
| forInStatement, | |
| forStatement, | |
| ifStatement, | |
| emptyStatement, | |
| expressionStatement, | |
| block, | |
| program, | |
| stringReference, | |
| typeReference, | |
| deferredHolderExpression, | |
| } | |
| /// Tags used for debugging serialization/deserialization boundary mismatches. | |
| class JsNodeTags { | |
| static const String tag = 'js-node'; | |
| static const String comment = 'js-comment'; | |
| static const String await = 'js-await'; | |
| static const String regExpLiteral = 'js-regExpLiteral'; | |
| static const String property = 'js-property'; | |
| static const String objectInitializer = 'js-objectInitializer'; | |
| static const String arrayHole = 'js-arrayHole'; | |
| static const String arrayInitializer = 'js-arrayInitializer'; | |
| static const String parentheses = 'js-parentheses'; | |
| static const String modularName = 'js-modularName'; | |
| static const String asyncName = 'js-asyncName'; | |
| static const String stringBackedName = 'js-stringBackedName'; | |
| static const String stringConcatenation = 'js-stringConcatenation'; | |
| static const String literalNull = 'js-literalNull'; | |
| static const String literalNumber = 'js-literalNumber'; | |
| static const String literalString = 'js-literalString'; | |
| static const String literalStringFromName = 'js-literalStringFromName'; | |
| static const String literalBool = 'js-literalBool'; | |
| static const String modularExpression = 'js-modularExpression'; | |
| static const String function = 'js-function'; | |
| static const String namedFunction = 'js-namedFunction'; | |
| static const String access = 'js-access'; | |
| static const String parameter = 'js-parameter'; | |
| static const String variableDeclaration = 'js-variableDeclaration'; | |
| static const String thisExpression = 'js-thisExpression'; | |
| static const String variableUse = 'js-variableUse'; | |
| static const String postfix = 'js-postfix'; | |
| static const String prefix = 'js-prefix'; | |
| static const String binary = 'js-binary'; | |
| static const String callExpression = 'js-callExpression'; | |
| static const String newExpression = 'js-newExpression'; | |
| static const String conditional = 'js-conditional'; | |
| static const String variableInitialization = 'js-variableInitialization'; | |
| static const String assignment = 'js-assignment'; | |
| static const String variableDeclarationList = 'js-variableDeclarationList'; | |
| static const String literalExpression = 'js-literalExpression'; | |
| static const String dartYield = 'js-dartYield'; | |
| static const String literalStatement = 'js-literalStatement'; | |
| static const String labeledStatement = 'js-labeledStatement'; | |
| static const String functionDeclaration = 'js-functionDeclaration'; | |
| static const String switchDefault = 'js-switchDefault'; | |
| static const String switchCase = 'js-switchCase'; | |
| static const String switchStatement = 'js-switchStatement'; | |
| static const String catchClause = 'js-catchClause'; | |
| static const String tryStatement = 'js-tryStatement'; | |
| static const String throwStatement = 'js-throwStatement'; | |
| static const String returnStatement = 'js-returnStatement'; | |
| static const String breakStatement = 'js-breakStatement'; | |
| static const String continueStatement = 'js-continueStatement'; | |
| static const String doStatement = 'js-doStatement'; | |
| static const String whileStatement = 'js-whileStatement'; | |
| static const String forInStatement = 'js-forInStatement'; | |
| static const String forStatement = 'js-forStatement'; | |
| static const String ifStatement = 'js-ifStatement'; | |
| static const String emptyStatement = 'js-emptyStatement'; | |
| static const String expressionStatement = 'js-expressionStatement'; | |
| static const String block = 'js-block'; | |
| static const String program = 'js-program'; | |
| static const String stringReference = 'js-stringReference'; | |
| static const String typeReference = 'js-typeReference'; | |
| static const String deferredHolderExpression = 'js-deferredHolderExpression'; | |
| } | |
| /// Visitor that serializes a [js.Node] into a [DataSink]. | |
| class JsNodeSerializer implements js.NodeVisitor<void> { | |
| final DataSink sink; | |
| JsNodeSerializer._(this.sink); | |
| static void writeToDataSink(DataSink sink, js.Node node) { | |
| sink.begin(JsNodeTags.tag); | |
| JsNodeSerializer serializer = new JsNodeSerializer._(sink); | |
| serializer.visit(node); | |
| sink.end(JsNodeTags.tag); | |
| } | |
| void visit(js.Node node, {bool allowNull: false}) { | |
| if (allowNull) { | |
| sink.writeBool(node != null); | |
| if (node != null) { | |
| node.accept(this); | |
| } | |
| } else { | |
| node.accept(this); | |
| } | |
| } | |
| void visitList(Iterable<js.Node> nodes) { | |
| sink.writeList(nodes, visit); | |
| } | |
| void _writeInfo(js.Node node) { | |
| sink.writeCached<SourceInformation>(node.sourceInformation, | |
| (SourceInformation sourceInformation) { | |
| SourceInformation.writeToDataSink(sink, sourceInformation); | |
| }); | |
| } | |
| @override | |
| void visitInterpolatedDeclaration(js.InterpolatedDeclaration node) { | |
| throw new UnsupportedError('JsNodeSerializer.visitInterpolatedDeclaration'); | |
| } | |
| @override | |
| void visitInterpolatedStatement(js.InterpolatedStatement node) { | |
| throw new UnsupportedError('JsNodeSerializer.visitInterpolatedStatement'); | |
| } | |
| @override | |
| void visitInterpolatedSelector(js.InterpolatedSelector node) { | |
| throw new UnsupportedError('JsNodeSerializer.visitInterpolatedDeclaration'); | |
| } | |
| @override | |
| void visitInterpolatedParameter(js.InterpolatedParameter node) { | |
| throw new UnsupportedError('JsNodeSerializer.visitInterpolatedParameter'); | |
| } | |
| @override | |
| void visitInterpolatedLiteral(js.InterpolatedLiteral node) { | |
| throw new UnsupportedError('JsNodeSerializer.visitInterpolatedLiteral'); | |
| } | |
| @override | |
| void visitInterpolatedExpression(js.InterpolatedExpression node) { | |
| throw new UnsupportedError('JsNodeSerializer.visitInterpolatedExpression'); | |
| } | |
| @override | |
| void visitComment(js.Comment node) { | |
| sink.writeEnum(JsNodeKind.comment); | |
| sink.begin(JsNodeTags.comment); | |
| sink.writeString(node.comment); | |
| sink.end(JsNodeTags.comment); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitAwait(js.Await node) { | |
| sink.writeEnum(JsNodeKind.await); | |
| sink.begin(JsNodeTags.await); | |
| visit(node.expression); | |
| sink.end(JsNodeTags.await); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitRegExpLiteral(js.RegExpLiteral node) { | |
| sink.writeEnum(JsNodeKind.regExpLiteral); | |
| sink.begin(JsNodeTags.regExpLiteral); | |
| sink.writeString(node.pattern); | |
| sink.end(JsNodeTags.regExpLiteral); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitProperty(js.Property node) { | |
| sink.writeEnum(JsNodeKind.property); | |
| sink.begin(JsNodeTags.property); | |
| visit(node.name); | |
| visit(node.value); | |
| sink.end(JsNodeTags.property); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitObjectInitializer(js.ObjectInitializer node) { | |
| sink.writeEnum(JsNodeKind.objectInitializer); | |
| sink.begin(JsNodeTags.objectInitializer); | |
| visitList(node.properties); | |
| sink.writeBool(node.isOneLiner); | |
| sink.end(JsNodeTags.objectInitializer); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitArrayHole(js.ArrayHole node) { | |
| sink.writeEnum(JsNodeKind.arrayHole); | |
| sink.begin(JsNodeTags.arrayHole); | |
| sink.end(JsNodeTags.arrayHole); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitArrayInitializer(js.ArrayInitializer node) { | |
| sink.writeEnum(JsNodeKind.arrayInitializer); | |
| sink.begin(JsNodeTags.arrayInitializer); | |
| visitList(node.elements); | |
| sink.end(JsNodeTags.arrayInitializer); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitParentheses(js.Parentheses node) { | |
| sink.writeEnum(JsNodeKind.parentheses); | |
| sink.begin(JsNodeTags.parentheses); | |
| visit(node.enclosed); | |
| sink.end(JsNodeTags.parentheses); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitName(js.Name node) { | |
| if (node is ModularName) { | |
| sink.writeEnum(JsNodeKind.modularName); | |
| sink.begin(JsNodeTags.modularName); | |
| node.writeToDataSink(sink); | |
| sink.end(JsNodeTags.modularName); | |
| _writeInfo(node); | |
| } else if (node is AsyncName) { | |
| sink.writeEnum(JsNodeKind.asyncName); | |
| sink.begin(JsNodeTags.asyncName); | |
| visit(node.prefix); | |
| visit(node.base); | |
| sink.end(JsNodeTags.asyncName); | |
| _writeInfo(node); | |
| } else if (node is StringBackedName) { | |
| sink.writeEnum(JsNodeKind.stringBackedName); | |
| sink.begin(JsNodeTags.stringBackedName); | |
| sink.writeString(node.name); | |
| sink.end(JsNodeTags.stringBackedName); | |
| _writeInfo(node); | |
| } else { | |
| throw new UnsupportedError( | |
| 'Unexpected deferred expression: ${node.runtimeType}.'); | |
| } | |
| } | |
| @override | |
| void visitStringConcatenation(js.StringConcatenation node) { | |
| sink.writeEnum(JsNodeKind.stringConcatenation); | |
| sink.begin(JsNodeTags.stringConcatenation); | |
| visitList(node.parts); | |
| sink.end(JsNodeTags.stringConcatenation); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitLiteralNull(js.LiteralNull node) { | |
| sink.writeEnum(JsNodeKind.literalNull); | |
| sink.begin(JsNodeTags.literalNull); | |
| sink.end(JsNodeTags.literalNull); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitLiteralNumber(js.LiteralNumber node) { | |
| sink.writeEnum(JsNodeKind.literalNumber); | |
| sink.begin(JsNodeTags.literalNumber); | |
| sink.writeString(node.value); | |
| sink.end(JsNodeTags.literalNumber); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitLiteralString(js.LiteralString node) { | |
| if (node is js.LiteralStringFromName) { | |
| sink.writeEnum(JsNodeKind.literalStringFromName); | |
| sink.begin(JsNodeTags.literalStringFromName); | |
| visit(node.name); | |
| sink.end(JsNodeTags.literalStringFromName); | |
| } else { | |
| sink.writeEnum(JsNodeKind.literalString); | |
| sink.begin(JsNodeTags.literalString); | |
| sink.writeString(node.value); | |
| sink.end(JsNodeTags.literalString); | |
| } | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitLiteralBool(js.LiteralBool node) { | |
| sink.writeEnum(JsNodeKind.literalBool); | |
| sink.begin(JsNodeTags.literalBool); | |
| sink.writeBool(node.value); | |
| sink.end(JsNodeTags.literalBool); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitDeferredString(js.DeferredString node) { | |
| throw new UnsupportedError('JsNodeSerializer.visitDeferredString'); | |
| } | |
| @override | |
| void visitDeferredStatement(js.DeferredStatement node) { | |
| throw new UnsupportedError('JsNodeSerializer.visitDeferredStatement'); | |
| } | |
| @override | |
| void visitDeferredNumber(js.DeferredNumber node) { | |
| throw new UnsupportedError('JsNodeSerializer.visitDeferredNumber'); | |
| } | |
| @override | |
| void visitDeferredExpression(js.DeferredExpression node) { | |
| if (node is ModularExpression) { | |
| sink.writeEnum(JsNodeKind.modularExpression); | |
| sink.begin(JsNodeTags.modularExpression); | |
| node.writeToDataSink(sink); | |
| sink.end(JsNodeTags.modularExpression); | |
| _writeInfo(node); | |
| } else if (node is TypeReference) { | |
| sink.writeEnum(JsNodeKind.typeReference); | |
| sink.begin(JsNodeTags.typeReference); | |
| node.writeToDataSink(sink); | |
| sink.end(JsNodeTags.typeReference); | |
| _writeInfo(node); | |
| } else if (node is StringReference) { | |
| sink.writeEnum(JsNodeKind.stringReference); | |
| sink.begin(JsNodeTags.stringReference); | |
| node.writeToDataSink(sink); | |
| sink.end(JsNodeTags.stringReference); | |
| _writeInfo(node); | |
| } else if (node is DeferredHolderExpression) { | |
| sink.writeEnum(JsNodeKind.deferredHolderExpression); | |
| sink.begin(JsNodeTags.deferredHolderExpression); | |
| node.writeToDataSink(sink); | |
| sink.end(JsNodeTags.deferredHolderExpression); | |
| _writeInfo(node); | |
| } else { | |
| throw new UnsupportedError( | |
| 'Unexpected deferred expression: ${node.runtimeType}.'); | |
| } | |
| } | |
| @override | |
| void visitFun(js.Fun node) { | |
| sink.writeEnum(JsNodeKind.function); | |
| sink.begin(JsNodeTags.function); | |
| visitList(node.params); | |
| visit(node.body); | |
| sink.writeEnum(node.asyncModifier); | |
| sink.end(JsNodeTags.function); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitNamedFunction(js.NamedFunction node) { | |
| sink.writeEnum(JsNodeKind.namedFunction); | |
| sink.begin(JsNodeTags.namedFunction); | |
| visit(node.name); | |
| visit(node.function); | |
| sink.end(JsNodeTags.namedFunction); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitAccess(js.PropertyAccess node) { | |
| sink.writeEnum(JsNodeKind.access); | |
| sink.begin(JsNodeTags.access); | |
| visit(node.receiver); | |
| visit(node.selector); | |
| sink.end(JsNodeTags.access); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitParameter(js.Parameter node) { | |
| sink.writeEnum(JsNodeKind.parameter); | |
| sink.begin(JsNodeTags.parameter); | |
| sink.writeString(node.name); | |
| sink.end(JsNodeTags.parameter); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitVariableDeclaration(js.VariableDeclaration node) { | |
| sink.writeEnum(JsNodeKind.variableDeclaration); | |
| sink.begin(JsNodeTags.variableDeclaration); | |
| sink.writeString(node.name); | |
| sink.writeBool(node.allowRename); | |
| sink.end(JsNodeTags.variableDeclaration); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitThis(js.This node) { | |
| sink.writeEnum(JsNodeKind.thisExpression); | |
| sink.begin(JsNodeTags.thisExpression); | |
| sink.end(JsNodeTags.thisExpression); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitVariableUse(js.VariableUse node) { | |
| sink.writeEnum(JsNodeKind.variableUse); | |
| sink.begin(JsNodeTags.variableUse); | |
| sink.writeString(node.name); | |
| sink.end(JsNodeTags.variableUse); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitPostfix(js.Postfix node) { | |
| sink.writeEnum(JsNodeKind.postfix); | |
| sink.begin(JsNodeTags.postfix); | |
| sink.writeString(node.op); | |
| visit(node.argument); | |
| sink.end(JsNodeTags.postfix); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitPrefix(js.Prefix node) { | |
| sink.writeEnum(JsNodeKind.prefix); | |
| sink.begin(JsNodeTags.prefix); | |
| sink.writeString(node.op); | |
| visit(node.argument); | |
| sink.end(JsNodeTags.prefix); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitBinary(js.Binary node) { | |
| sink.writeEnum(JsNodeKind.binary); | |
| sink.begin(JsNodeTags.binary); | |
| sink.writeString(node.op); | |
| visit(node.left); | |
| visit(node.right); | |
| sink.end(JsNodeTags.binary); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitCall(js.Call node) { | |
| sink.writeEnum(JsNodeKind.callExpression); | |
| sink.begin(JsNodeTags.callExpression); | |
| visit(node.target); | |
| visitList(node.arguments); | |
| sink.end(JsNodeTags.callExpression); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitNew(js.New node) { | |
| sink.writeEnum(JsNodeKind.newExpression); | |
| sink.begin(JsNodeTags.newExpression); | |
| visit(node.target); | |
| visitList(node.arguments); | |
| sink.end(JsNodeTags.newExpression); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitConditional(js.Conditional node) { | |
| sink.writeEnum(JsNodeKind.conditional); | |
| sink.begin(JsNodeTags.conditional); | |
| visit(node.condition); | |
| visit(node.then); | |
| visit(node.otherwise); | |
| sink.end(JsNodeTags.conditional); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitVariableInitialization(js.VariableInitialization node) { | |
| sink.writeEnum(JsNodeKind.variableInitialization); | |
| sink.begin(JsNodeTags.variableInitialization); | |
| visit(node.declaration); | |
| visit(node.value, allowNull: true); | |
| sink.end(JsNodeTags.variableInitialization); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitAssignment(js.Assignment node) { | |
| sink.writeEnum(JsNodeKind.assignment); | |
| sink.begin(JsNodeTags.assignment); | |
| visit(node.leftHandSide); | |
| sink.writeStringOrNull(node.op); | |
| visit(node.value); | |
| sink.end(JsNodeTags.assignment); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitVariableDeclarationList(js.VariableDeclarationList node) { | |
| sink.writeEnum(JsNodeKind.variableDeclarationList); | |
| sink.begin(JsNodeTags.variableDeclarationList); | |
| visitList(node.declarations); | |
| sink.writeBool(node.indentSplits); | |
| sink.end(JsNodeTags.variableDeclarationList); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitLiteralExpression(js.LiteralExpression node) { | |
| sink.writeEnum(JsNodeKind.literalExpression); | |
| sink.begin(JsNodeTags.literalExpression); | |
| sink.writeString(node.template); | |
| sink.end(JsNodeTags.literalExpression); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitDartYield(js.DartYield node) { | |
| sink.writeEnum(JsNodeKind.dartYield); | |
| sink.begin(JsNodeTags.dartYield); | |
| visit(node.expression); | |
| sink.writeBool(node.hasStar); | |
| sink.end(JsNodeTags.dartYield); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitLiteralStatement(js.LiteralStatement node) { | |
| sink.writeEnum(JsNodeKind.literalStatement); | |
| sink.begin(JsNodeTags.literalStatement); | |
| sink.writeString(node.code); | |
| sink.end(JsNodeTags.literalStatement); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitLabeledStatement(js.LabeledStatement node) { | |
| sink.writeEnum(JsNodeKind.labeledStatement); | |
| sink.begin(JsNodeTags.labeledStatement); | |
| sink.writeString(node.label); | |
| visit(node.body); | |
| sink.end(JsNodeTags.labeledStatement); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitFunctionDeclaration(js.FunctionDeclaration node) { | |
| sink.writeEnum(JsNodeKind.functionDeclaration); | |
| sink.begin(JsNodeTags.functionDeclaration); | |
| visit(node.name); | |
| visit(node.function); | |
| sink.end(JsNodeTags.functionDeclaration); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitDefault(js.Default node) { | |
| sink.writeEnum(JsNodeKind.switchDefault); | |
| sink.begin(JsNodeTags.switchDefault); | |
| visit(node.body); | |
| sink.end(JsNodeTags.switchDefault); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitCase(js.Case node) { | |
| sink.writeEnum(JsNodeKind.switchCase); | |
| sink.begin(JsNodeTags.switchCase); | |
| visit(node.expression); | |
| visit(node.body); | |
| sink.end(JsNodeTags.switchCase); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitSwitch(js.Switch node) { | |
| sink.writeEnum(JsNodeKind.switchStatement); | |
| sink.begin(JsNodeTags.switchStatement); | |
| visit(node.key); | |
| visitList(node.cases); | |
| sink.end(JsNodeTags.switchStatement); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitCatch(js.Catch node) { | |
| sink.writeEnum(JsNodeKind.catchClause); | |
| sink.begin(JsNodeTags.catchClause); | |
| visit(node.declaration); | |
| visit(node.body); | |
| sink.end(JsNodeTags.catchClause); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitTry(js.Try node) { | |
| sink.writeEnum(JsNodeKind.tryStatement); | |
| sink.begin(JsNodeTags.tryStatement); | |
| visit(node.body); | |
| visit(node.catchPart, allowNull: true); | |
| visit(node.finallyPart, allowNull: true); | |
| sink.end(JsNodeTags.tryStatement); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitThrow(js.Throw node) { | |
| sink.writeEnum(JsNodeKind.throwStatement); | |
| sink.begin(JsNodeTags.throwStatement); | |
| visit(node.expression); | |
| sink.end(JsNodeTags.throwStatement); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitReturn(js.Return node) { | |
| sink.writeEnum(JsNodeKind.returnStatement); | |
| sink.begin(JsNodeTags.returnStatement); | |
| visit(node.value, allowNull: true); | |
| sink.end(JsNodeTags.returnStatement); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitBreak(js.Break node) { | |
| sink.writeEnum(JsNodeKind.breakStatement); | |
| sink.begin(JsNodeTags.breakStatement); | |
| sink.writeStringOrNull(node.targetLabel); | |
| sink.end(JsNodeTags.breakStatement); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitContinue(js.Continue node) { | |
| sink.writeEnum(JsNodeKind.continueStatement); | |
| sink.begin(JsNodeTags.continueStatement); | |
| sink.writeStringOrNull(node.targetLabel); | |
| sink.end(JsNodeTags.continueStatement); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitDo(js.Do node) { | |
| sink.writeEnum(JsNodeKind.doStatement); | |
| sink.begin(JsNodeTags.doStatement); | |
| visit(node.body); | |
| visit(node.condition); | |
| sink.end(JsNodeTags.doStatement); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitWhile(js.While node) { | |
| sink.writeEnum(JsNodeKind.whileStatement); | |
| sink.begin(JsNodeTags.whileStatement); | |
| visit(node.condition); | |
| visit(node.body); | |
| sink.end(JsNodeTags.whileStatement); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitForIn(js.ForIn node) { | |
| sink.writeEnum(JsNodeKind.forInStatement); | |
| sink.begin(JsNodeTags.forInStatement); | |
| visit(node.leftHandSide); | |
| visit(node.object); | |
| visit(node.body); | |
| sink.end(JsNodeTags.forInStatement); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitFor(js.For node) { | |
| sink.writeEnum(JsNodeKind.forStatement); | |
| sink.begin(JsNodeTags.forStatement); | |
| visit(node.init, allowNull: true); | |
| visit(node.condition, allowNull: true); | |
| visit(node.update, allowNull: true); | |
| visit(node.body); | |
| sink.end(JsNodeTags.forStatement); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitIf(js.If node) { | |
| sink.writeEnum(JsNodeKind.ifStatement); | |
| sink.begin(JsNodeTags.ifStatement); | |
| visit(node.condition); | |
| visit(node.then); | |
| visit(node.otherwise); | |
| sink.end(JsNodeTags.ifStatement); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitEmptyStatement(js.EmptyStatement node) { | |
| sink.writeEnum(JsNodeKind.emptyStatement); | |
| sink.begin(JsNodeTags.emptyStatement); | |
| sink.end(JsNodeTags.emptyStatement); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitExpressionStatement(js.ExpressionStatement node) { | |
| sink.writeEnum(JsNodeKind.expressionStatement); | |
| sink.begin(JsNodeTags.expressionStatement); | |
| visit(node.expression); | |
| sink.end(JsNodeTags.expressionStatement); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitBlock(js.Block node) { | |
| sink.writeEnum(JsNodeKind.block); | |
| sink.begin(JsNodeTags.block); | |
| visitList(node.statements); | |
| sink.end(JsNodeTags.block); | |
| _writeInfo(node); | |
| } | |
| @override | |
| void visitProgram(js.Program node) { | |
| sink.writeEnum(JsNodeKind.program); | |
| sink.begin(JsNodeTags.program); | |
| visitList(node.body); | |
| sink.end(JsNodeTags.program); | |
| _writeInfo(node); | |
| } | |
| } | |
| /// Helper class that deserializes a [js.Node] from [DataSource]. | |
| /// | |
| /// Deserialized [ModularName]s and [ModularExpression]s are collected in the | |
| /// [modularNames] and [modularExpressions] lists. | |
| class JsNodeDeserializer { | |
| final DataSource source; | |
| final List<ModularName> modularNames; | |
| final List<ModularExpression> modularExpressions; | |
| JsNodeDeserializer._(this.source, this.modularNames, this.modularExpressions); | |
| static js.Node readFromDataSource( | |
| DataSource source, | |
| List<ModularName> modularNames, | |
| List<ModularExpression> modularExpressions) { | |
| source.begin(JsNodeTags.tag); | |
| JsNodeDeserializer deserializer = | |
| new JsNodeDeserializer._(source, modularNames, modularExpressions); | |
| js.Node node = deserializer.read(); | |
| source.end(JsNodeTags.tag); | |
| return node; | |
| } | |
| T read<T extends js.Node>({bool allowNull: false}) { | |
| if (allowNull) { | |
| bool hasValue = source.readBool(); | |
| if (!hasValue) return null; | |
| } | |
| JsNodeKind kind = source.readEnum(JsNodeKind.values); | |
| js.Node node; | |
| switch (kind) { | |
| case JsNodeKind.comment: | |
| source.begin(JsNodeTags.comment); | |
| node = new js.Comment(source.readString()); | |
| source.end(JsNodeTags.comment); | |
| break; | |
| case JsNodeKind.await: | |
| source.begin(JsNodeTags.await); | |
| node = new js.Await(read()); | |
| source.end(JsNodeTags.await); | |
| break; | |
| case JsNodeKind.regExpLiteral: | |
| source.begin(JsNodeTags.regExpLiteral); | |
| node = new js.RegExpLiteral(source.readString()); | |
| source.end(JsNodeTags.regExpLiteral); | |
| break; | |
| case JsNodeKind.property: | |
| source.begin(JsNodeTags.property); | |
| js.Expression name = read(); | |
| js.Expression value = read(); | |
| node = new js.Property(name, value); | |
| source.end(JsNodeTags.property); | |
| break; | |
| case JsNodeKind.objectInitializer: | |
| source.begin(JsNodeTags.objectInitializer); | |
| List<js.Property> properties = readList(); | |
| bool isOneLiner = source.readBool(); | |
| node = new js.ObjectInitializer(properties, isOneLiner: isOneLiner); | |
| source.end(JsNodeTags.objectInitializer); | |
| break; | |
| case JsNodeKind.arrayHole: | |
| source.begin(JsNodeTags.arrayHole); | |
| node = new js.ArrayHole(); | |
| source.end(JsNodeTags.arrayHole); | |
| break; | |
| case JsNodeKind.arrayInitializer: | |
| source.begin(JsNodeTags.arrayInitializer); | |
| List<js.Expression> elements = readList(); | |
| node = new js.ArrayInitializer(elements); | |
| source.end(JsNodeTags.arrayInitializer); | |
| break; | |
| case JsNodeKind.parentheses: | |
| source.begin(JsNodeTags.parentheses); | |
| node = new js.Parentheses(read()); | |
| source.end(JsNodeTags.parentheses); | |
| break; | |
| case JsNodeKind.modularName: | |
| source.begin(JsNodeTags.modularName); | |
| ModularName modularName = ModularName.readFromDataSource(source); | |
| modularNames.add(modularName); | |
| node = modularName; | |
| source.end(JsNodeTags.modularName); | |
| break; | |
| case JsNodeKind.asyncName: | |
| source.begin(JsNodeTags.asyncName); | |
| js.Name prefix = read(); | |
| js.Name base = read(); | |
| node = new AsyncName(prefix, base); | |
| source.end(JsNodeTags.asyncName); | |
| break; | |
| case JsNodeKind.stringBackedName: | |
| source.begin(JsNodeTags.stringBackedName); | |
| node = new StringBackedName(source.readString()); | |
| source.end(JsNodeTags.stringBackedName); | |
| break; | |
| case JsNodeKind.stringConcatenation: | |
| source.begin(JsNodeTags.stringConcatenation); | |
| List<js.Literal> parts = readList(); | |
| node = new js.StringConcatenation(parts); | |
| source.end(JsNodeTags.stringConcatenation); | |
| break; | |
| case JsNodeKind.literalNull: | |
| source.begin(JsNodeTags.literalNull); | |
| node = new js.LiteralNull(); | |
| source.end(JsNodeTags.literalNull); | |
| break; | |
| case JsNodeKind.literalNumber: | |
| source.begin(JsNodeTags.literalNumber); | |
| node = new js.LiteralNumber(source.readString()); | |
| source.end(JsNodeTags.literalNumber); | |
| break; | |
| case JsNodeKind.literalString: | |
| source.begin(JsNodeTags.literalString); | |
| node = new js.LiteralString(source.readString()); | |
| source.end(JsNodeTags.literalString); | |
| break; | |
| case JsNodeKind.literalStringFromName: | |
| source.begin(JsNodeTags.literalStringFromName); | |
| js.Name name = read(); | |
| node = new js.LiteralStringFromName(name); | |
| source.end(JsNodeTags.literalStringFromName); | |
| break; | |
| case JsNodeKind.literalBool: | |
| source.begin(JsNodeTags.literalBool); | |
| node = new js.LiteralBool(source.readBool()); | |
| source.end(JsNodeTags.literalBool); | |
| break; | |
| case JsNodeKind.modularExpression: | |
| source.begin(JsNodeTags.modularExpression); | |
| ModularExpression modularExpression = | |
| ModularExpression.readFromDataSource(source); | |
| modularExpressions.add(modularExpression); | |
| node = modularExpression; | |
| source.end(JsNodeTags.modularExpression); | |
| break; | |
| case JsNodeKind.function: | |
| source.begin(JsNodeTags.function); | |
| List<js.Parameter> params = readList(); | |
| js.Block body = read(); | |
| js.AsyncModifier asyncModifier = | |
| source.readEnum(js.AsyncModifier.values); | |
| node = new js.Fun(params, body, asyncModifier: asyncModifier); | |
| source.end(JsNodeTags.function); | |
| break; | |
| case JsNodeKind.namedFunction: | |
| source.begin(JsNodeTags.namedFunction); | |
| js.Declaration name = read(); | |
| js.Fun function = read(); | |
| node = new js.NamedFunction(name, function); | |
| source.end(JsNodeTags.namedFunction); | |
| break; | |
| case JsNodeKind.access: | |
| source.begin(JsNodeTags.access); | |
| js.Expression receiver = read(); | |
| js.Expression selector = read(); | |
| node = new js.PropertyAccess(receiver, selector); | |
| source.end(JsNodeTags.access); | |
| break; | |
| case JsNodeKind.parameter: | |
| source.begin(JsNodeTags.parameter); | |
| node = new js.Parameter(source.readString()); | |
| source.end(JsNodeTags.parameter); | |
| break; | |
| case JsNodeKind.variableDeclaration: | |
| source.begin(JsNodeTags.variableDeclaration); | |
| String name = source.readString(); | |
| bool allowRename = source.readBool(); | |
| node = new js.VariableDeclaration(name, allowRename: allowRename); | |
| source.end(JsNodeTags.variableDeclaration); | |
| break; | |
| case JsNodeKind.thisExpression: | |
| source.begin(JsNodeTags.thisExpression); | |
| node = new js.This(); | |
| source.end(JsNodeTags.thisExpression); | |
| break; | |
| case JsNodeKind.variableUse: | |
| source.begin(JsNodeTags.variableUse); | |
| node = new js.VariableUse(source.readString()); | |
| source.end(JsNodeTags.variableUse); | |
| break; | |
| case JsNodeKind.postfix: | |
| source.begin(JsNodeTags.postfix); | |
| String op = source.readString(); | |
| js.Expression argument = read(); | |
| node = new js.Postfix(op, argument); | |
| source.end(JsNodeTags.postfix); | |
| break; | |
| case JsNodeKind.prefix: | |
| source.begin(JsNodeTags.prefix); | |
| String op = source.readString(); | |
| js.Expression argument = read(); | |
| node = new js.Prefix(op, argument); | |
| source.end(JsNodeTags.prefix); | |
| break; | |
| case JsNodeKind.binary: | |
| source.begin(JsNodeTags.binary); | |
| String op = source.readString(); | |
| js.Expression left = read(); | |
| js.Expression right = read(); | |
| node = new js.Binary(op, left, right); | |
| source.end(JsNodeTags.binary); | |
| break; | |
| case JsNodeKind.callExpression: | |
| source.begin(JsNodeTags.callExpression); | |
| js.Expression target = read(); | |
| List<js.Expression> arguments = readList(); | |
| node = new js.Call(target, arguments); | |
| source.end(JsNodeTags.callExpression); | |
| break; | |
| case JsNodeKind.newExpression: | |
| source.begin(JsNodeTags.newExpression); | |
| js.Expression cls = read(); | |
| List<js.Expression> arguments = readList(); | |
| node = new js.New(cls, arguments); | |
| source.end(JsNodeTags.newExpression); | |
| break; | |
| case JsNodeKind.conditional: | |
| source.begin(JsNodeTags.conditional); | |
| js.Expression condition = read(); | |
| js.Expression then = read(); | |
| js.Expression otherwise = read(); | |
| node = new js.Conditional(condition, then, otherwise); | |
| source.end(JsNodeTags.conditional); | |
| break; | |
| case JsNodeKind.variableInitialization: | |
| source.begin(JsNodeTags.variableInitialization); | |
| js.Declaration declaration = read(); | |
| js.Expression value = source.readValueOrNull(read); | |
| node = new js.VariableInitialization(declaration, value); | |
| source.end(JsNodeTags.variableInitialization); | |
| break; | |
| case JsNodeKind.assignment: | |
| source.begin(JsNodeTags.assignment); | |
| js.Expression leftHandSide = read(); | |
| String op = source.readStringOrNull(); | |
| js.Expression value = read(); | |
| node = new js.Assignment.compound(leftHandSide, op, value); | |
| source.end(JsNodeTags.assignment); | |
| break; | |
| case JsNodeKind.variableDeclarationList: | |
| source.begin(JsNodeTags.variableDeclarationList); | |
| List<js.VariableInitialization> declarations = readList(); | |
| bool indentSplits = source.readBool(); | |
| node = new js.VariableDeclarationList(declarations, | |
| indentSplits: indentSplits); | |
| source.end(JsNodeTags.variableDeclarationList); | |
| break; | |
| case JsNodeKind.literalExpression: | |
| source.begin(JsNodeTags.literalExpression); | |
| node = new js.LiteralExpression(source.readString()); | |
| source.end(JsNodeTags.literalExpression); | |
| break; | |
| case JsNodeKind.dartYield: | |
| source.begin(JsNodeTags.dartYield); | |
| js.Expression expression = read(); | |
| bool hasStar = source.readBool(); | |
| node = new js.DartYield(expression, hasStar); | |
| source.end(JsNodeTags.dartYield); | |
| break; | |
| case JsNodeKind.literalStatement: | |
| source.begin(JsNodeTags.literalStatement); | |
| node = new js.LiteralStatement(source.readString()); | |
| source.end(JsNodeTags.literalStatement); | |
| break; | |
| case JsNodeKind.labeledStatement: | |
| source.begin(JsNodeTags.labeledStatement); | |
| String label = source.readString(); | |
| js.Statement body = read(); | |
| node = new js.LabeledStatement(label, body); | |
| source.end(JsNodeTags.labeledStatement); | |
| break; | |
| case JsNodeKind.functionDeclaration: | |
| source.begin(JsNodeTags.functionDeclaration); | |
| js.Declaration name = read(); | |
| js.Fun function = read(); | |
| node = new js.FunctionDeclaration(name, function); | |
| source.end(JsNodeTags.functionDeclaration); | |
| break; | |
| case JsNodeKind.switchDefault: | |
| source.begin(JsNodeTags.switchDefault); | |
| js.Block body = read(); | |
| node = new js.Default(body); | |
| source.end(JsNodeTags.switchDefault); | |
| break; | |
| case JsNodeKind.switchCase: | |
| source.begin(JsNodeTags.switchCase); | |
| js.Expression expression = read(); | |
| js.Block body = read(); | |
| node = new js.Case(expression, body); | |
| source.end(JsNodeTags.switchCase); | |
| break; | |
| case JsNodeKind.switchStatement: | |
| source.begin(JsNodeTags.switchStatement); | |
| js.Expression key = read(); | |
| List<js.SwitchClause> cases = readList(); | |
| node = new js.Switch(key, cases); | |
| source.end(JsNodeTags.switchStatement); | |
| break; | |
| case JsNodeKind.catchClause: | |
| source.begin(JsNodeTags.catchClause); | |
| js.Declaration declaration = read(); | |
| js.Block body = read(); | |
| node = new js.Catch(declaration, body); | |
| source.end(JsNodeTags.catchClause); | |
| break; | |
| case JsNodeKind.tryStatement: | |
| source.begin(JsNodeTags.tryStatement); | |
| js.Block body = read(); | |
| js.Catch catchPart = source.readValueOrNull(read); | |
| js.Block finallyPart = source.readValueOrNull(read); | |
| node = new js.Try(body, catchPart, finallyPart); | |
| source.end(JsNodeTags.tryStatement); | |
| break; | |
| case JsNodeKind.throwStatement: | |
| source.begin(JsNodeTags.throwStatement); | |
| js.Expression expression = read(); | |
| node = new js.Throw(expression); | |
| source.end(JsNodeTags.throwStatement); | |
| break; | |
| case JsNodeKind.returnStatement: | |
| source.begin(JsNodeTags.returnStatement); | |
| js.Expression value = source.readValueOrNull(read); | |
| node = new js.Return(value); | |
| source.end(JsNodeTags.returnStatement); | |
| break; | |
| case JsNodeKind.breakStatement: | |
| source.begin(JsNodeTags.breakStatement); | |
| String targetLabel = source.readStringOrNull(); | |
| node = new js.Break(targetLabel); | |
| source.end(JsNodeTags.breakStatement); | |
| break; | |
| case JsNodeKind.continueStatement: | |
| source.begin(JsNodeTags.continueStatement); | |
| String targetLabel = source.readStringOrNull(); | |
| node = new js.Continue(targetLabel); | |
| source.end(JsNodeTags.continueStatement); | |
| break; | |
| case JsNodeKind.doStatement: | |
| source.begin(JsNodeTags.doStatement); | |
| js.Statement body = read(); | |
| js.Expression condition = read(); | |
| node = new js.Do(body, condition); | |
| source.end(JsNodeTags.doStatement); | |
| break; | |
| case JsNodeKind.whileStatement: | |
| source.begin(JsNodeTags.whileStatement); | |
| js.Expression condition = read(); | |
| js.Statement body = read(); | |
| node = new js.While(condition, body); | |
| source.end(JsNodeTags.whileStatement); | |
| break; | |
| case JsNodeKind.forInStatement: | |
| source.begin(JsNodeTags.forInStatement); | |
| js.Expression leftHandSide = read(); | |
| js.Expression object = read(); | |
| js.Statement body = read(); | |
| node = new js.ForIn(leftHandSide, object, body); | |
| source.end(JsNodeTags.forInStatement); | |
| break; | |
| case JsNodeKind.forStatement: | |
| source.begin(JsNodeTags.forStatement); | |
| js.Expression init = read(allowNull: true); | |
| js.Expression condition = read(allowNull: true); | |
| js.Expression update = read(allowNull: true); | |
| js.Statement body = read(); | |
| node = new js.For(init, condition, update, body); | |
| source.end(JsNodeTags.forStatement); | |
| break; | |
| case JsNodeKind.ifStatement: | |
| source.begin(JsNodeTags.ifStatement); | |
| js.Expression condition = read(); | |
| js.Statement then = read(); | |
| js.Statement otherwise = read(); | |
| node = new js.If(condition, then, otherwise); | |
| source.end(JsNodeTags.ifStatement); | |
| break; | |
| case JsNodeKind.emptyStatement: | |
| source.begin(JsNodeTags.emptyStatement); | |
| node = new js.EmptyStatement(); | |
| source.end(JsNodeTags.emptyStatement); | |
| break; | |
| case JsNodeKind.expressionStatement: | |
| source.begin(JsNodeTags.expressionStatement); | |
| node = new js.ExpressionStatement(read()); | |
| source.end(JsNodeTags.expressionStatement); | |
| break; | |
| case JsNodeKind.block: | |
| source.begin(JsNodeTags.block); | |
| List<js.Statement> statements = readList(); | |
| node = new js.Block(statements); | |
| source.end(JsNodeTags.block); | |
| break; | |
| case JsNodeKind.program: | |
| source.begin(JsNodeTags.program); | |
| List<js.Statement> body = readList(); | |
| node = new js.Program(body); | |
| source.end(JsNodeTags.program); | |
| break; | |
| case JsNodeKind.stringReference: | |
| source.begin(JsNodeTags.stringReference); | |
| node = StringReference.readFromDataSource(source); | |
| source.end(JsNodeTags.stringReference); | |
| break; | |
| case JsNodeKind.typeReference: | |
| source.begin(JsNodeTags.typeReference); | |
| node = TypeReference.readFromDataSource(source); | |
| source.end(JsNodeTags.typeReference); | |
| break; | |
| case JsNodeKind.deferredHolderExpression: | |
| source.begin(JsNodeTags.deferredHolderExpression); | |
| node = DeferredHolderExpression.readFromDataSource(source); | |
| source.end(JsNodeTags.deferredHolderExpression); | |
| break; | |
| } | |
| SourceInformation sourceInformation = | |
| source.readCached<SourceInformation>(() { | |
| return SourceInformation.readFromDataSource(source); | |
| }); | |
| if (sourceInformation != null) { | |
| node = node.withSourceInformation(sourceInformation); | |
| } | |
| return node; | |
| } | |
| List<T> readList<T extends js.Node>({bool emptyAsNull: false}) { | |
| return source.readList(read, emptyAsNull: emptyAsNull); | |
| } | |
| } | |
| class CodegenReaderImpl implements CodegenReader { | |
| final JClosedWorld closedWorld; | |
| final List<ModularName> modularNames; | |
| final List<ModularExpression> modularExpressions; | |
| CodegenReaderImpl( | |
| this.closedWorld, this.modularNames, this.modularExpressions); | |
| @override | |
| AbstractValue readAbstractValue(DataSource source) { | |
| return closedWorld.abstractValueDomain | |
| .readAbstractValueFromDataSource(source); | |
| } | |
| @override | |
| js.Node readJsNode(DataSource source) { | |
| return JsNodeDeserializer.readFromDataSource( | |
| source, modularNames, modularExpressions); | |
| } | |
| @override | |
| OutputUnit readOutputUnitReference(DataSource source) { | |
| return closedWorld.outputUnitData.outputUnits[source.readInt()]; | |
| } | |
| @override | |
| TypeRecipe readTypeRecipe(DataSource source) { | |
| return TypeRecipe.readFromDataSource(source); | |
| } | |
| } | |
| class CodegenWriterImpl implements CodegenWriter { | |
| final JClosedWorld closedWorld; | |
| CodegenWriterImpl(this.closedWorld); | |
| @override | |
| void writeAbstractValue(DataSink sink, AbstractValue value) { | |
| closedWorld.abstractValueDomain.writeAbstractValueToDataSink(sink, value); | |
| } | |
| @override | |
| void writeJsNode(DataSink sink, js.Node node) { | |
| JsNodeSerializer.writeToDataSink(sink, node); | |
| } | |
| @override | |
| void writeOutputUnitReference(DataSink sink, OutputUnit value) { | |
| sink.writeInt(closedWorld.outputUnitData.outputUnits.indexOf(value)); | |
| } | |
| @override | |
| void writeTypeRecipe(DataSink sink, TypeRecipe recipe) { | |
| recipe.writeToDataSink(sink); | |
| } | |
| } |