From 05cce14437c05d98216234c2a92e0dc0858368e6 Mon Sep 17 00:00:00 2001 From: Konstantin Shcheglov Date: Mon, 14 Dec 2020 05:50:57 +0000 Subject: [PATCH] Write markers into resolution stream. Change-Id: I84092ac81b67637d2975ae331034207027740191 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/175960 Reviewed-by: Brian Wilkerson Commit-Queue: Konstantin Shcheglov --- .../lib/src/dart/analysis/driver.dart | 8 +- .../lib/src/summary2/apply_resolution.dart | 407 ++++++++++++++++-- .../lib/src/summary2/ast_binary_flags.dart | 11 + .../lib/src/summary2/ast_binary_tag.dart | 318 ++++++++++++++ .../lib/src/summary2/ast_binary_writer.dart | 352 ++++++++++++++- .../lib/src/summary2/bundle_writer.dart | 4 + 6 files changed, 1048 insertions(+), 52 deletions(-) diff --git a/pkg/analyzer/lib/src/dart/analysis/driver.dart b/pkg/analyzer/lib/src/dart/analysis/driver.dart index 464857c26e13e..2f7c02679b571 100644 --- a/pkg/analyzer/lib/src/dart/analysis/driver.dart +++ b/pkg/analyzer/lib/src/dart/analysis/driver.dart @@ -41,6 +41,7 @@ import 'package:analyzer/src/summary/api_signature.dart'; import 'package:analyzer/src/summary/format.dart'; import 'package:analyzer/src/summary/idl.dart'; import 'package:analyzer/src/summary/package_bundle_reader.dart'; +import 'package:analyzer/src/summary2/ast_binary_flags.dart'; import 'package:meta/meta.dart'; /// TODO(scheglov) We could use generalized Function in @@ -85,7 +86,7 @@ typedef WorkToWaitAfterComputingResult = Future Function(String path); /// TODO(scheglov) Clean up the list of implicitly analyzed files. class AnalysisDriver implements AnalysisDriverGeneric { /// The version of data format, should be incremented on every format change. - static const int DATA_VERSION = 117; + static const int DATA_VERSION = 118; /// The length of the list returned by [_computeDeclaredVariablesSignature]. static const int _declaredVariablesSignatureLength = 4; @@ -147,7 +148,7 @@ class AnalysisDriver implements AnalysisDriverGeneric { _declaredVariablesSignatureLength); /// The salt to mix into all hashes used as keys for linked data. - final Uint32List _saltForResolution = Uint32List(2 + + final Uint32List _saltForResolution = Uint32List(3 + AnalysisOptionsImpl.signatureLength + _declaredVariablesSignatureLength); @@ -1596,6 +1597,9 @@ class AnalysisDriver implements AnalysisDriverGeneric { _saltForResolution[index] = enableIndex ? 1 : 0; index++; + _saltForResolution[index] = enableDebugResolutionMarkers ? 1 : 0; + index++; + _saltForResolution.setAll(index, _analysisOptions.signature); index += AnalysisOptionsImpl.signatureLength; diff --git a/pkg/analyzer/lib/src/summary2/apply_resolution.dart b/pkg/analyzer/lib/src/summary2/apply_resolution.dart index ce901493cf62e..e254ae4d9af13 100644 --- a/pkg/analyzer/lib/src/summary2/apply_resolution.dart +++ b/pkg/analyzer/lib/src/summary2/apply_resolution.dart @@ -14,6 +14,7 @@ import 'package:analyzer/src/dart/ast/utilities.dart'; import 'package:analyzer/src/dart/element/element.dart'; import 'package:analyzer/src/dart/resolver/variance.dart'; import 'package:analyzer/src/exception/exception.dart'; +import 'package:analyzer/src/summary2/ast_binary_flags.dart'; import 'package:analyzer/src/summary2/ast_binary_tag.dart'; import 'package:analyzer/src/summary2/bundle_reader.dart'; import 'package:analyzer/src/summary2/linked_unit_context.dart'; @@ -80,61 +81,92 @@ class ApplyResolutionVisitor extends ThrowingAstVisitor { @override void visitAnnotation(Annotation node) { + _expectMarker(MarkerTag.Annotation_name); node.name.accept(this); + _expectMarker(MarkerTag.Annotation_constructorName); node.constructorName?.accept(this); + _expectMarker(MarkerTag.Annotation_arguments); node.arguments?.accept(this); + _expectMarker(MarkerTag.Annotation_element); node.element = _nextElement(); } @override void visitArgumentList(ArgumentList node) { + _expectMarker(MarkerTag.ArgumentList_arguments); node.arguments.accept(this); + _expectMarker(MarkerTag.ArgumentList_end); } @override void visitAsExpression(AsExpression node) { + _expectMarker(MarkerTag.AsExpression_expression); node.expression.accept(this); + _expectMarker(MarkerTag.AsExpression_type); node.type.accept(this); + _expectMarker(MarkerTag.AsExpression_expression2); _expression(node); + _expectMarker(MarkerTag.AsExpression_end); } @override void visitAssertInitializer(AssertInitializer node) { + _expectMarker(MarkerTag.AssertInitializer_condition); node.condition.accept(this); + _expectMarker(MarkerTag.AssertInitializer_message); node.message?.accept(this); + _expectMarker(MarkerTag.AssertInitializer_end); } @override void visitAssignmentExpression(AssignmentExpression node) { var nodeImpl = node as AssignmentExpressionImpl; + _expectMarker(MarkerTag.AssignmentExpression_leftHandSide); node.leftHandSide.accept(this); + _expectMarker(MarkerTag.AssignmentExpression_rightHandSide); node.rightHandSide.accept(this); + _expectMarker(MarkerTag.AssignmentExpression_staticElement); node.staticElement = _nextElement(); + _expectMarker(MarkerTag.AssignmentExpression_readElement); nodeImpl.readElement = _nextElement(); + _expectMarker(MarkerTag.AssignmentExpression_readType); nodeImpl.readType = _nextType(); + _expectMarker(MarkerTag.AssignmentExpression_writeElement); nodeImpl.writeElement = _nextElement(); + _expectMarker(MarkerTag.AssignmentExpression_writeType); nodeImpl.writeType = _nextType(); + _expectMarker(MarkerTag.AssignmentExpression_expression); _expression(node); + _expectMarker(MarkerTag.AssignmentExpression_end); } @override void visitBinaryExpression(BinaryExpression node) { + _expectMarker(MarkerTag.BinaryExpression_leftOperand); node.leftOperand.accept(this); + _expectMarker(MarkerTag.BinaryExpression_rightOperand); node.rightOperand.accept(this); + _expectMarker(MarkerTag.BinaryExpression_staticElement); node.staticElement = _nextElement(); - node.staticType = _nextType(); + + _expectMarker(MarkerTag.BinaryExpression_expression); + _expression(node); + _expectMarker(MarkerTag.BinaryExpression_end); } @override void visitBooleanLiteral(BooleanLiteral node) { - node.staticType = _nextType(); + _expression(node); } @override void visitCascadeExpression(CascadeExpression node) { + _expectMarker(MarkerTag.CascadeExpression_target); node.target.accept(this); + _expectMarker(MarkerTag.CascadeExpression_cascadeSections); node.cascadeSections.accept(this); + _expectMarker(MarkerTag.CascadeExpression_end); node.staticType = node.target.staticType; } @@ -147,12 +179,19 @@ class ApplyResolutionVisitor extends ThrowingAstVisitor { _enclosingElements.add(element); try { + _expectMarker(MarkerTag.ClassDeclaration_typeParameters); node.typeParameters?.accept(this); + _expectMarker(MarkerTag.ClassDeclaration_extendsClause); node.extendsClause?.accept(this); - node.nativeClause?.accept(this); + _expectMarker(MarkerTag.ClassDeclaration_withClause); node.withClause?.accept(this); + _expectMarker(MarkerTag.ClassDeclaration_implementsClause); node.implementsClause?.accept(this); + _expectMarker(MarkerTag.ClassDeclaration_nativeClause); + node.nativeClause?.accept(this); + _expectMarker(MarkerTag.ClassDeclaration_namedCompilationUnitMember); _namedCompilationUnitMember(node); + _expectMarker(MarkerTag.ClassDeclaration_end); } catch (e, stackTrace) { // TODO(scheglov) Remove after fixing http://dartbug.com/44449 var headerStr = _astCodeBeforeMarkerOrMaxLength(node, '{', 1000); @@ -176,28 +215,41 @@ resolution.byteOffset: ${_resolution.byteOffset} _enclosingElements.add(element); element.isSimplyBounded = _resolution.readByte() != 0; + _expectMarker(MarkerTag.ClassTypeAlias_typeParameters); node.typeParameters?.accept(this); + _expectMarker(MarkerTag.ClassTypeAlias_superclass); node.superclass?.accept(this); + _expectMarker(MarkerTag.ClassTypeAlias_withClause); node.withClause?.accept(this); + _expectMarker(MarkerTag.ClassTypeAlias_implementsClause); node.implementsClause?.accept(this); - node.metadata?.accept(this); + _expectMarker(MarkerTag.ClassTypeAlias_typeAlias); + _typeAlias(node); + _expectMarker(MarkerTag.ClassTypeAlias_end); _enclosingElements.removeLast(); } @override void visitConditionalExpression(ConditionalExpression node) { + _expectMarker(MarkerTag.ConditionalExpression_condition); node.condition.accept(this); + _expectMarker(MarkerTag.ConditionalExpression_thenExpression); node.thenExpression.accept(this); + _expectMarker(MarkerTag.ConditionalExpression_elseExpression); node.elseExpression.accept(this); - node.staticType = _nextType(); + _expression(node); } @override void visitConfiguration(Configuration node) { + _expectMarker(MarkerTag.Configuration_name); node.name?.accept(this); + _expectMarker(MarkerTag.Configuration_value); node.value?.accept(this); + _expectMarker(MarkerTag.Configuration_uri); node.uri?.accept(this); + _expectMarker(MarkerTag.Configuration_end); } @override @@ -209,16 +261,22 @@ resolution.byteOffset: ${_resolution.byteOffset} _enclosingElements.add(element.enclosingElement); _enclosingElements.add(element); + _expectMarker(MarkerTag.ConstructorDeclaration_returnType); node.returnType?.accept(this); + _expectMarker(MarkerTag.ConstructorDeclaration_parameters); node.parameters?.accept(this); for (var parameter in node.parameters.parameters) { _localElements.add(parameter.declaredElement); } + _expectMarker(MarkerTag.ConstructorDeclaration_initializers); node.initializers?.accept(this); + _expectMarker(MarkerTag.ConstructorDeclaration_redirectedConstructor); node.redirectedConstructor?.accept(this); - node.metadata?.accept(this); + _expectMarker(MarkerTag.ConstructorDeclaration_classMember); + _classMember(node); + _expectMarker(MarkerTag.ConstructorDeclaration_end); _enclosingElements.removeLast(); _enclosingElements.removeLast(); @@ -226,8 +284,11 @@ resolution.byteOffset: ${_resolution.byteOffset} @override void visitConstructorFieldInitializer(ConstructorFieldInitializer node) { + _expectMarker(MarkerTag.ConstructorFieldInitializer_fieldName); node.fieldName.accept(this); + _expectMarker(MarkerTag.ConstructorFieldInitializer_expression); node.expression.accept(this); + _expectMarker(MarkerTag.ConstructorFieldInitializer_end); } @override @@ -252,16 +313,24 @@ resolution.byteOffset: ${_resolution.byteOffset} node.name = typeName.identifier; } + _expectMarker(MarkerTag.ConstructorName_type); node.type.accept(this); + _expectMarker(MarkerTag.ConstructorName_name); node.name?.accept(this); + _expectMarker(MarkerTag.ConstructorName_staticElement); node.staticElement = _nextElement(); + _expectMarker(MarkerTag.ConstructorName_end); } @override void visitDeclaredIdentifier(DeclaredIdentifier node) { + _expectMarker(MarkerTag.DeclaredIdentifier_type); node.type?.accept(this); + _expectMarker(MarkerTag.DeclaredIdentifier_identifier); // node.identifier.accept(this); + _expectMarker(MarkerTag.DeclaredIdentifier_declaration); _declaration(node); + _expectMarker(MarkerTag.DeclaredIdentifier_end); } @override @@ -285,8 +354,11 @@ resolution.byteOffset: ${_resolution.byteOffset} var summaryData = nodeImpl.summaryData as SummaryDataForFormalParameter; element.setCodeRange(summaryData.codeOffset, summaryData.codeLength); + _expectMarker(MarkerTag.DefaultFormalParameter_parameter); node.parameter.accept(this); + _expectMarker(MarkerTag.DefaultFormalParameter_defaultValue); node.defaultValue?.accept(this); + _expectMarker(MarkerTag.DefaultFormalParameter_end); } @override @@ -301,19 +373,28 @@ resolution.byteOffset: ${_resolution.byteOffset} @override void visitEnumConstantDeclaration(EnumConstantDeclaration node) { - node.metadata?.accept(this); + _expectMarker(MarkerTag.EnumConstantDeclaration_name); + _expectMarker(MarkerTag.EnumConstantDeclaration_declaration); + _declaration(node); + _expectMarker(MarkerTag.EnumConstantDeclaration_end); } @override void visitEnumDeclaration(EnumDeclaration node) { + _expectMarker(MarkerTag.EnumDeclaration_constants); node.constants.accept(this); - node.metadata?.accept(this); + _expectMarker(MarkerTag.EnumDeclaration_namedCompilationUnitMember); + _namedCompilationUnitMember(node); + _expectMarker(MarkerTag.EnumDeclaration_end); } @override void visitExportDirective(ExportDirective node) { + _expectMarker(MarkerTag.ExportDirective_namespaceDirective); _namespaceDirective(node); + _expectMarker(MarkerTag.ExportDirective_exportedLibrary); (node.element as ExportElementImpl).exportedLibrary = _nextElement(); + _expectMarker(MarkerTag.ExportDirective_end); } @override @@ -323,7 +404,9 @@ resolution.byteOffset: ${_resolution.byteOffset} @override visitExtendsClause(ExtendsClause node) { + _expectMarker(MarkerTag.ExtendsClause_superclass); node.superclass.accept(this); + _expectMarker(MarkerTag.ExtendsClause_end); } @override @@ -333,9 +416,13 @@ resolution.byteOffset: ${_resolution.byteOffset} var element = node.declaredElement as ExtensionElementImpl; _enclosingElements.add(element); + _expectMarker(MarkerTag.ExtensionDeclaration_typeParameters); node.typeParameters?.accept(this); + _expectMarker(MarkerTag.ExtensionDeclaration_extendedType); node.extendedType?.accept(this); - node.metadata?.accept(this); + _expectMarker(MarkerTag.ExtensionDeclaration_compilationUnitMember); + _compilationUnitMember(node); + _expectMarker(MarkerTag.ExtensionDeclaration_end); _enclosingElements.removeLast(); } @@ -351,10 +438,15 @@ resolution.byteOffset: ${_resolution.byteOffset} _resolution.readByte(); } + _expectMarker(MarkerTag.ExtensionOverride_extensionName); node.extensionName.accept(this); + _expectMarker(MarkerTag.ExtensionOverride_typeArguments); node.typeArguments?.accept(this); + _expectMarker(MarkerTag.ExtensionOverride_argumentList); node.argumentList.accept(this); + _expectMarker(MarkerTag.ExtensionOverride_extendedType); (node as ExtensionOverrideImpl).extendedType = _nextType(); + _expectMarker(MarkerTag.ExtensionOverride_end); // TODO(scheglov) typeArgumentTypes? } @@ -363,8 +455,11 @@ resolution.byteOffset: ${_resolution.byteOffset} _assertNoLocalElements(); _pushEnclosingClassTypeParameters(node); + _expectMarker(MarkerTag.FieldDeclaration_fields); node.fields.accept(this); - node.metadata?.accept(this); + _expectMarker(MarkerTag.FieldDeclaration_classMember); + _classMember(node); + _expectMarker(MarkerTag.FieldDeclaration_end); } @override @@ -378,29 +473,42 @@ resolution.byteOffset: ${_resolution.byteOffset} var localElementsLength = _localElements.length; + _expectMarker(MarkerTag.FieldFormalParameter_typeParameters); node.typeParameters?.accept(this); + _expectMarker(MarkerTag.FieldFormalParameter_type); node.type?.accept(this); + _expectMarker(MarkerTag.FieldFormalParameter_parameters); node.parameters?.accept(this); + _expectMarker(MarkerTag.FieldFormalParameter_normalFormalParameter); _normalFormalParameter(node, element); + _expectMarker(MarkerTag.FieldFormalParameter_end); _localElements.length = localElementsLength; } @override void visitForEachPartsWithDeclaration(ForEachPartsWithDeclaration node) { + _expectMarker(MarkerTag.ForEachPartsWithDeclaration_loopVariable); node.loopVariable.accept(this); + _expectMarker(MarkerTag.ForEachPartsWithDeclaration_forEachParts); _forEachParts(node); + _expectMarker(MarkerTag.ForEachPartsWithDeclaration_end); } @override void visitForElement(ForElement node) { + _expectMarker(MarkerTag.ForElement_body); node.body.accept(this); - node.forLoopParts.accept(this); + _expectMarker(MarkerTag.ForElement_forMixin); + _forMixin(node as ForElementImpl); + _expectMarker(MarkerTag.ForElement_end); } @override visitFormalParameterList(FormalParameterList node) { + _expectMarker(MarkerTag.FormalParameterList_parameters); node.parameters.accept(this); + _expectMarker(MarkerTag.FormalParameterList_end); } @override @@ -412,8 +520,11 @@ resolution.byteOffset: ${_resolution.byteOffset} nameNode.offset, ); } + _expectMarker(MarkerTag.ForPartsWithDeclarations_variables); node.variables.accept(this); + _expectMarker(MarkerTag.ForPartsWithDeclarations_forParts); _forParts(node); + _expectMarker(MarkerTag.ForPartsWithDeclarations_end); } @override @@ -425,17 +536,25 @@ resolution.byteOffset: ${_resolution.byteOffset} _enclosingElements.add(element); + _expectMarker(MarkerTag.FunctionDeclaration_functionExpression); node.functionExpression.accept(this); + _expectMarker(MarkerTag.FunctionDeclaration_returnType); node.returnType?.accept(this); - node.metadata?.accept(this); + _expectMarker(MarkerTag.FunctionDeclaration_namedCompilationUnitMember); + _namedCompilationUnitMember(node); + _expectMarker(MarkerTag.FunctionDeclaration_returnTypeType); element.returnType = _nextType(); + _expectMarker(MarkerTag.FunctionDeclaration_end); } @override void visitFunctionExpression(FunctionExpression node) { + _expectMarker(MarkerTag.FunctionExpression_typeParameters); node.typeParameters?.accept(this); + _expectMarker(MarkerTag.FunctionExpression_parameters); node.parameters?.accept(this); + _expectMarker(MarkerTag.FunctionExpression_end); } @override @@ -449,8 +568,11 @@ resolution.byteOffset: ${_resolution.byteOffset} _resolution.readByte(); } + _expectMarker(MarkerTag.FunctionExpressionInvocation_function); node.function.accept(this); + _expectMarker(MarkerTag.FunctionExpressionInvocation_invocationExpression); _invocationExpression(node); + _expectMarker(MarkerTag.FunctionExpressionInvocation_end); } @override @@ -460,18 +582,25 @@ resolution.byteOffset: ${_resolution.byteOffset} var element = node.declaredElement as FunctionTypeAliasElementImpl; _enclosingElements.add(element); + _expectMarker(MarkerTag.FunctionTypeAlias_typeParameters); node.typeParameters?.accept(this); _enclosingElements.add(element.function); + _expectMarker(MarkerTag.FunctionTypeAlias_returnType); node.returnType?.accept(this); + _expectMarker(MarkerTag.FunctionTypeAlias_parameters); node.parameters?.accept(this); _enclosingElements.removeLast(); - node.metadata?.accept(this); + _expectMarker(MarkerTag.FunctionTypeAlias_typeAlias); + _typeAlias(node); + _expectMarker(MarkerTag.FunctionTypeAlias_returnTypeType); element.function.returnType = _nextType(); + _expectMarker(MarkerTag.FunctionTypeAlias_flags); element.isSimplyBounded = _resolution.readByte() != 0; element.hasSelfReference = _resolution.readByte() != 0; + _expectMarker(MarkerTag.FunctionTypeAlias_end); _enclosingElements.removeLast(); } @@ -487,10 +616,15 @@ resolution.byteOffset: ${_resolution.byteOffset} var localElementsLength = _localElements.length; + _expectMarker(MarkerTag.FunctionTypedFormalParameter_typeParameters); node.typeParameters?.accept(this); + _expectMarker(MarkerTag.FunctionTypedFormalParameter_returnType); node.returnType?.accept(this); + _expectMarker(MarkerTag.FunctionTypedFormalParameter_parameters); node.parameters?.accept(this); + _expectMarker(MarkerTag.FunctionTypedFormalParameter_normalFormalParameter); _normalFormalParameter(node, element); + _expectMarker(MarkerTag.FunctionTypedFormalParameter_end); _localElements.length = localElementsLength; } @@ -505,10 +639,15 @@ resolution.byteOffset: ${_resolution.byteOffset} _enclosingElements.last, null, node); _enclosingElements.add(element); + _expectMarker(MarkerTag.GenericFunctionType_typeParameters); node.typeParameters?.accept(this); + _expectMarker(MarkerTag.GenericFunctionType_returnType); node.returnType?.accept(this); + _expectMarker(MarkerTag.GenericFunctionType_parameters); node.parameters?.accept(this); + _expectMarker(MarkerTag.GenericFunctionType_type); nodeImpl.type = _nextType(); + _expectMarker(MarkerTag.GenericFunctionType_end); _localElements.length = localElementsLength; _enclosingElements.removeLast(); @@ -523,11 +662,16 @@ resolution.byteOffset: ${_resolution.byteOffset} _enclosingElements.add(element); + _expectMarker(MarkerTag.GenericTypeAlias_typeParameters); node.typeParameters?.accept(this); + _expectMarker(MarkerTag.GenericTypeAlias_type); node.type?.accept(this); - node.metadata?.accept(this); + _expectMarker(MarkerTag.GenericTypeAlias_typeAlias); + _typeAlias(node); + _expectMarker(MarkerTag.GenericTypeAlias_flags); element.isSimplyBounded = _resolution.readByte() != 0; element.hasSelfReference = _resolution.readByte() != 0; + _expectMarker(MarkerTag.GenericTypeAlias_end); _enclosingElements.removeLast(); } @@ -539,30 +683,45 @@ resolution.byteOffset: ${_resolution.byteOffset} @override void visitIfElement(IfElement node) { + _expectMarker(MarkerTag.IfElement_condition); node.condition.accept(this); + _expectMarker(MarkerTag.IfElement_thenElement); node.thenElement.accept(this); + _expectMarker(MarkerTag.IfElement_elseElement); node.elseElement?.accept(this); + _expectMarker(MarkerTag.IfElement_end); } @override visitImplementsClause(ImplementsClause node) { + _expectMarker(MarkerTag.ImplementsClause_interfaces); node.interfaces.accept(this); + _expectMarker(MarkerTag.ImplementsClause_end); } @override void visitImportDirective(ImportDirective node) { + _expectMarker(MarkerTag.ImportDirective_namespaceDirective); _namespaceDirective(node); var element = node.element as ImportElementImpl; + _expectMarker(MarkerTag.ImportDirective_importedLibrary); element.importedLibrary = _nextElement(); + + _expectMarker(MarkerTag.ImportDirective_end); } @override void visitIndexExpression(IndexExpression node) { + _expectMarker(MarkerTag.IndexExpression_target); node.target?.accept(this); + _expectMarker(MarkerTag.IndexExpression_index); node.index.accept(this); + _expectMarker(MarkerTag.IndexExpression_staticElement); node.staticElement = _nextElement(); + _expectMarker(MarkerTag.IndexExpression_expression); _expression(node); + _expectMarker(MarkerTag.IndexExpression_end); } @override @@ -576,10 +735,13 @@ resolution.byteOffset: ${_resolution.byteOffset} _resolution.readByte(); } + _expectMarker(MarkerTag.InstanceCreationExpression_constructorName); node.constructorName.accept(this); - (node as InstanceCreationExpressionImpl).typeArguments?.accept(this); + _expectMarker(MarkerTag.InstanceCreationExpression_argumentList); node.argumentList.accept(this); - node.staticType = _nextType(); + _expectMarker(MarkerTag.InstanceCreationExpression_expression); + _expression(node); + _expectMarker(MarkerTag.InstanceCreationExpression_end); _resolveNamedExpressions( node.constructorName.staticElement, node.argumentList, @@ -588,7 +750,7 @@ resolution.byteOffset: ${_resolution.byteOffset} @override void visitIntegerLiteral(IntegerLiteral node) { - node.staticType = _nextType(); + _expression(node); } @override @@ -603,9 +765,13 @@ resolution.byteOffset: ${_resolution.byteOffset} @override void visitIsExpression(IsExpression node) { + _expectMarker(MarkerTag.IsExpression_expression); node.expression.accept(this); + _expectMarker(MarkerTag.IsExpression_type); node.type.accept(this); + _expectMarker(MarkerTag.IsExpression_expression2); _expression(node); + _expectMarker(MarkerTag.IsExpression_end); } @override @@ -621,14 +787,20 @@ resolution.byteOffset: ${_resolution.byteOffset} @override void visitListLiteral(ListLiteral node) { + _expectMarker(MarkerTag.ListLiteral_typeArguments); node.typeArguments?.accept(this); + _expectMarker(MarkerTag.ListLiteral_elements); node.elements.accept(this); - node.staticType = _nextType(); + _expectMarker(MarkerTag.ListLiteral_expression); + _expression(node); + _expectMarker(MarkerTag.ListLiteral_end); } @override void visitMapLiteralEntry(MapLiteralEntry node) { + _expectMarker(MarkerTag.MapLiteralEntry_key); node.key.accept(this); + _expectMarker(MarkerTag.MapLiteralEntry_value); node.value.accept(this); } @@ -642,17 +814,25 @@ resolution.byteOffset: ${_resolution.byteOffset} _enclosingElements.add(element); try { + _expectMarker(MarkerTag.MethodDeclaration_typeParameters); node.typeParameters?.accept(this); + _expectMarker(MarkerTag.MethodDeclaration_returnType); node.returnType?.accept(this); + _expectMarker(MarkerTag.MethodDeclaration_parameters); node.parameters?.accept(this); - node.metadata?.accept(this); + _expectMarker(MarkerTag.MethodDeclaration_classMember); + _classMember(node); + _expectMarker(MarkerTag.MethodDeclaration_returnTypeType); element.returnType = _nextType(); + _expectMarker(MarkerTag.MethodDeclaration_inferenceError); _setTopLevelInferenceError(element); if (element is MethodElementImpl) { + _expectMarker(MarkerTag.MethodDeclaration_flags); element.isOperatorEqualWithParameterTypeFromObject = _resolution.readByte() != 0; } + _expectMarker(MarkerTag.MethodDeclaration_end); } catch (e, stackTrace) { // TODO(scheglov) Remove after fixing http://dartbug.com/44449 var headerStr = _astCodeBeforeMarkerOrMaxLength(node, '{', 1000); @@ -754,9 +934,13 @@ resolution.byteOffset: ${_resolution.byteOffset} throw StateError('[rewriteTag: $rewriteTag][node: $node]'); } + _expectMarker(MarkerTag.MethodInvocation_target); node.target?.accept(this); + _expectMarker(MarkerTag.MethodInvocation_methodName); node.methodName.accept(this); + _expectMarker(MarkerTag.MethodInvocation_invocationExpression); _invocationExpression(node); + _expectMarker(MarkerTag.MethodInvocation_end); } @override @@ -767,22 +951,31 @@ resolution.byteOffset: ${_resolution.byteOffset} element.superInvokedNames = _resolution.readStringList(); _enclosingElements.add(element); + _expectMarker(MarkerTag.MixinDeclaration_typeParameters); node.typeParameters?.accept(this); + _expectMarker(MarkerTag.MixinDeclaration_onClause); node.onClause?.accept(this); + _expectMarker(MarkerTag.MixinDeclaration_implementsClause); node.implementsClause?.accept(this); - node.metadata?.accept(this); + _expectMarker(MarkerTag.MixinDeclaration_namedCompilationUnitMember); + _namedCompilationUnitMember(node); + _expectMarker(MarkerTag.MixinDeclaration_end); _enclosingElements.removeLast(); } @override void visitNamedExpression(NamedExpression node) { + _expectMarker(MarkerTag.NamedExpression_expression); node.expression.accept(this); + _expectMarker(MarkerTag.NamedExpression_end); } @override void visitNativeClause(NativeClause node) { + _expectMarker(MarkerTag.NativeClause_name); node.name.accept(this); + _expectMarker(MarkerTag.NativeClause_end); } @override @@ -792,13 +985,18 @@ resolution.byteOffset: ${_resolution.byteOffset} @override void visitOnClause(OnClause node) { + _expectMarker(MarkerTag.OnClause_superclassConstraints); node.superclassConstraints.accept(this); + _expectMarker(MarkerTag.OnClause_end); } @override void visitParenthesizedExpression(ParenthesizedExpression node) { + _expectMarker(MarkerTag.ParenthesizedExpression_expression); node.expression.accept(this); - node.staticType = _nextType(); + _expectMarker(MarkerTag.ParenthesizedExpression_expression2); + _expression(node); + _expectMarker(MarkerTag.ParenthesizedExpression_end); } @override @@ -808,64 +1006,98 @@ resolution.byteOffset: ${_resolution.byteOffset} @override void visitPartOfDirective(PartOfDirective node) { + _expectMarker(MarkerTag.PartOfDirective_libraryName); + node.libraryName?.accept(this); + _expectMarker(MarkerTag.PartOfDirective_uri); node.uri?.accept(this); + _expectMarker(MarkerTag.PartOfDirective_directive); _directive(node); + _expectMarker(MarkerTag.PartOfDirective_end); } @override void visitPostfixExpression(PostfixExpression node) { var nodeImpl = node as PostfixExpressionImpl; + _expectMarker(MarkerTag.PostfixExpression_operand); node.operand.accept(this); + _expectMarker(MarkerTag.PostfixExpression_staticElement); node.staticElement = _nextElement(); if (node.operator.type.isIncrementOperator) { + _expectMarker(MarkerTag.PostfixExpression_readElement); nodeImpl.readElement = _nextElement(); + _expectMarker(MarkerTag.PostfixExpression_readType); nodeImpl.readType = _nextType(); + _expectMarker(MarkerTag.PostfixExpression_writeElement); nodeImpl.writeElement = _nextElement(); + _expectMarker(MarkerTag.PostfixExpression_writeType); nodeImpl.writeType = _nextType(); } + _expectMarker(MarkerTag.PostfixExpression_expression); _expression(node); + _expectMarker(MarkerTag.PostfixExpression_end); } @override void visitPrefixedIdentifier(PrefixedIdentifier node) { + _expectMarker(MarkerTag.PrefixedIdentifier_prefix); node.prefix.accept(this); + _expectMarker(MarkerTag.PrefixedIdentifier_identifier); node.identifier.accept(this); + _expectMarker(MarkerTag.PrefixedIdentifier_expression); _expression(node); + _expectMarker(MarkerTag.PrefixedIdentifier_end); } @override void visitPrefixExpression(PrefixExpression node) { var nodeImpl = node as PrefixExpressionImpl; + _expectMarker(MarkerTag.PrefixExpression_operand); node.operand.accept(this); + _expectMarker(MarkerTag.PrefixExpression_staticElement); node.staticElement = _nextElement(); if (node.operator.type.isIncrementOperator) { + _expectMarker(MarkerTag.PrefixExpression_readElement); nodeImpl.readElement = _nextElement(); + _expectMarker(MarkerTag.PrefixExpression_readType); nodeImpl.readType = _nextType(); + _expectMarker(MarkerTag.PrefixExpression_writeElement); nodeImpl.writeElement = _nextElement(); + _expectMarker(MarkerTag.PrefixExpression_writeType); nodeImpl.writeType = _nextType(); } + _expectMarker(MarkerTag.PrefixExpression_expression); _expression(node); + _expectMarker(MarkerTag.PrefixExpression_end); } @override void visitPropertyAccess(PropertyAccess node) { + _expectMarker(MarkerTag.PropertyAccess_target); node.target?.accept(this); + _expectMarker(MarkerTag.PropertyAccess_propertyName); node.propertyName.accept(this); - node.staticType = _nextType(); + _expectMarker(MarkerTag.PropertyAccess_expression); + _expression(node); + _expectMarker(MarkerTag.PropertyAccess_end); } @override void visitRedirectingConstructorInvocation( RedirectingConstructorInvocation node) { + _expectMarker(MarkerTag.RedirectingConstructorInvocation_constructorName); node.constructorName?.accept(this); + _expectMarker(MarkerTag.RedirectingConstructorInvocation_argumentList); node.argumentList.accept(this); + _expectMarker(MarkerTag.RedirectingConstructorInvocation_staticElement); node.staticElement = _nextElement(); _resolveNamedExpressions(node.staticElement, node.argumentList); + _expectMarker(MarkerTag.RedirectingConstructorInvocation_end); } @override void visitSetOrMapLiteral(SetOrMapLiteral node) { + _expectMarker(MarkerTag.SetOrMapLiteral_flags); var mapOrSetBits = _resolution.readByte(); if ((mapOrSetBits & 0x01) != 0) { (node as SetOrMapLiteralImpl).becomeMap(); @@ -873,9 +1105,13 @@ resolution.byteOffset: ${_resolution.byteOffset} (node as SetOrMapLiteralImpl).becomeSet(); } + _expectMarker(MarkerTag.SetOrMapLiteral_typeArguments); node.typeArguments?.accept(this); + _expectMarker(MarkerTag.SetOrMapLiteral_elements); node.elements.accept(this); - node.staticType = _nextType(); + _expectMarker(MarkerTag.SetOrMapLiteral_expression); + _expression(node); + _expectMarker(MarkerTag.SetOrMapLiteral_end); } @override @@ -892,16 +1128,23 @@ resolution.byteOffset: ${_resolution.byteOffset} ParameterElementImpl.forLinkedNodeFactory(enclosing, null, node); } + _expectMarker(MarkerTag.SimpleFormalParameter_type); node.type?.accept(this); + _expectMarker(MarkerTag.SimpleFormalParameter_normalFormalParameter); _normalFormalParameter(node, element); + _expectMarker(MarkerTag.SimpleFormalParameter_flags); element.inheritsCovariant = _resolution.readByte() != 0; + _expectMarker(MarkerTag.SimpleFormalParameter_end); } @override visitSimpleIdentifier(SimpleIdentifier node) { + _expectMarker(MarkerTag.SimpleIdentifier_staticElement); node.staticElement = _nextElement(); - node.staticType = _nextType(); + _expectMarker(MarkerTag.SimpleIdentifier_expression); + _expression(node); + _expectMarker(MarkerTag.SimpleIdentifier_end); } @override @@ -911,61 +1154,86 @@ resolution.byteOffset: ${_resolution.byteOffset} @override void visitSpreadElement(SpreadElement node) { + _expectMarker(MarkerTag.SpreadElement_expression); node.expression.accept(this); + _expectMarker(MarkerTag.SpreadElement_end); } @override void visitStringInterpolation(StringInterpolation node) { + _expectMarker(MarkerTag.StringInterpolation_elements); node.elements.accept(this); + _expectMarker(MarkerTag.StringInterpolation_end); // TODO(scheglov) type? } @override void visitSuperConstructorInvocation(SuperConstructorInvocation node) { + _expectMarker(MarkerTag.SuperConstructorInvocation_constructorName); node.constructorName?.accept(this); + _expectMarker(MarkerTag.SuperConstructorInvocation_argumentList); node.argumentList.accept(this); + _expectMarker(MarkerTag.SuperConstructorInvocation_staticElement); node.staticElement = _nextElement(); _resolveNamedExpressions(node.staticElement, node.argumentList); + _expectMarker(MarkerTag.SuperConstructorInvocation_end); } @override void visitSuperExpression(SuperExpression node) { - node.staticType = _nextType(); + _expectMarker(MarkerTag.SuperExpression_expression); + _expression(node); + _expectMarker(MarkerTag.SuperExpression_end); } @override void visitSymbolLiteral(SymbolLiteral node) { - node.staticType = _nextType(); + _expression(node); } @override void visitThisExpression(ThisExpression node) { - node.staticType = _nextType(); + _expectMarker(MarkerTag.ThisExpression_expression); + _expression(node); + _expectMarker(MarkerTag.ThisExpression_end); } @override void visitThrowExpression(ThrowExpression node) { + _expectMarker(MarkerTag.ThrowExpression_expression); node.expression.accept(this); - node.staticType = _nextType(); + _expectMarker(MarkerTag.ThrowExpression_expression2); + _expression(node); + _expectMarker(MarkerTag.ThrowExpression_end); } @override void visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) { + _expectMarker(MarkerTag.TopLevelVariableDeclaration_variables); node.variables.accept(this); - node.metadata?.accept(this); + _expectMarker(MarkerTag.TopLevelVariableDeclaration_compilationUnitMember); + _compilationUnitMember(node); + _expectMarker(MarkerTag.TopLevelVariableDeclaration_end); } @override visitTypeArgumentList(TypeArgumentList node) { + _expectMarker(MarkerTag.TypeArgumentList_arguments); node.arguments?.accept(this); + _expectMarker(MarkerTag.TypeArgumentList_end); } @override visitTypeName(TypeName node) { + _expectMarker(MarkerTag.TypeName_name); node.name.accept(this); + _expectMarker(MarkerTag.TypeName_typeArguments); node.typeArguments?.accept(this); + _expectMarker(MarkerTag.TypeName_type); node.type = _nextType(); + + _expectMarker(MarkerTag.TypeName_end); } @override @@ -978,6 +1246,7 @@ resolution.byteOffset: ${_resolution.byteOffset} _localElements.add(element); } + _expectMarker(MarkerTag.TypeParameterList_typeParameters); for (var node in node.typeParameters) { var nodeImpl = node as TypeParameterImpl; var element = node.declaredElement as TypeParameterElementImpl; @@ -985,17 +1254,22 @@ resolution.byteOffset: ${_resolution.byteOffset} var summaryData = nodeImpl.summaryData as SummaryDataForTypeParameter; element.setCodeRange(summaryData.codeOffset, summaryData.codeLength); + _expectMarker(MarkerTag.TypeParameter_bound); node.bound?.accept(this); element.bound = node.bound?.type; - node.metadata.accept(this); + _expectMarker(MarkerTag.TypeParameter_declaration); + _declaration(node); element.metadata = _buildAnnotations( _unitContext.element, node.metadata, ); + _expectMarker(MarkerTag.TypeParameter_variance); element.variance = _decodeVariance(_resolution.readByte()); + _expectMarker(MarkerTag.TypeParameter_defaultType); element.defaultType = _nextType(); + _expectMarker(MarkerTag.TypeParameter_end); // TODO(scheglov) We used to do this with the previous elements impl. // We probably still do this. @@ -1025,34 +1299,48 @@ resolution.byteOffset: ${_resolution.byteOffset} } } } + _expectMarker(MarkerTag.TypeParameterList_end); } @override void visitVariableDeclaration(VariableDeclaration node) { var element = node.declaredElement as VariableElementImpl; + _expectMarker(MarkerTag.VariableDeclaration_type); element.type = _nextType(); + _expectMarker(MarkerTag.VariableDeclaration_inferenceError); _setTopLevelInferenceError(element); if (element is FieldElementImpl) { + _expectMarker(MarkerTag.VariableDeclaration_inheritsCovariant); element.inheritsCovariant = _resolution.readByte() != 0; } + _expectMarker(MarkerTag.VariableDeclaration_initializer); node.initializer?.accept(this); + _expectMarker(MarkerTag.VariableDeclaration_end); } @override void visitVariableDeclarationList(VariableDeclarationList node) { + _expectMarker(MarkerTag.VariableDeclarationList_type); node.type?.accept(this); + _expectMarker(MarkerTag.VariableDeclarationList_variables); node.variables.accept(this); - node.metadata?.accept(this); + _expectMarker(MarkerTag.VariableDeclarationList_annotatedNode); + _annotatedNode(node); + _expectMarker(MarkerTag.VariableDeclarationList_end); } @override void visitWithClause(WithClause node) { + _expectMarker(MarkerTag.WithClause_mixinTypes); node.mixinTypes.accept(this); + _expectMarker(MarkerTag.WithClause_end); } void _annotatedNode(AnnotatedNode node) { + _expectMarker(MarkerTag.AnnotatedNode_metadata); node.metadata?.accept(this); + _expectMarker(MarkerTag.AnnotatedNode_end); } void _assertNoLocalElements() { @@ -1079,6 +1367,11 @@ resolution.byteOffset: ${_resolution.byteOffset} return annotations; } + void _classMember(ClassMember node) { + _expectMarker(MarkerTag.ClassMember_declaration); + _declaration(node); + } + void _compilationUnitMember(CompilationUnitMember node) { _declaration(node); } @@ -1088,34 +1381,66 @@ resolution.byteOffset: ${_resolution.byteOffset} } void _directive(Directive node) { - node.metadata?.accept(this); + _annotatedNode(node); + } + + void _expectMarker(MarkerTag tag) { + if (enableDebugResolutionMarkers) { + var actualIndex = _resolution.readUInt30(); + if (actualIndex != tag.index) { + if (actualIndex < MarkerTag.values.length) { + var actualTag = MarkerTag.values[actualIndex]; + throw StateError('Expected $tag, found $actualIndex = $actualTag'); + } else { + throw StateError('Expected $tag, found $actualIndex'); + } + } + } } void _expression(Expression node) { + _expectMarker(MarkerTag.Expression_staticType); node.staticType = _nextType(); } void _forEachParts(ForEachParts node) { - _forLoopParts(node); + _expectMarker(MarkerTag.ForEachParts_iterable); node.iterable.accept(this); + _expectMarker(MarkerTag.ForEachParts_forLoopParts); + _forLoopParts(node); + _expectMarker(MarkerTag.ForEachParts_end); } void _forLoopParts(ForLoopParts node) {} void _formalParameter(FormalParameter node) { + _expectMarker(MarkerTag.FormalParameter_type); (node.declaredElement as ParameterElementImpl).type = _nextType(); } + void _forMixin(ForMixin node) { + _expectMarker(MarkerTag.ForMixin_forLoopParts); + node.forLoopParts.accept(this); + } + void _forParts(ForParts node) { + _expectMarker(MarkerTag.ForParts_condition); node.condition?.accept(this); + _expectMarker(MarkerTag.ForParts_updaters); node.updaters.accept(this); + _expectMarker(MarkerTag.ForParts_forLoopParts); _forLoopParts(node); + _expectMarker(MarkerTag.ForParts_end); } void _invocationExpression(InvocationExpression node) { + _expectMarker(MarkerTag.InvocationExpression_typeArguments); node.typeArguments?.accept(this); + _expectMarker(MarkerTag.InvocationExpression_argumentList); node.argumentList.accept(this); + _expectMarker(MarkerTag.InvocationExpression_expression); _expression(node); + _expectMarker(MarkerTag.InvocationExpression_end); // TODO(scheglov) typeArgumentTypes and staticInvokeType? var nodeImpl = node as InvocationExpressionImpl; nodeImpl.typeArgumentTypes = []; @@ -1126,9 +1451,13 @@ resolution.byteOffset: ${_resolution.byteOffset} } void _namespaceDirective(NamespaceDirective node) { + _expectMarker(MarkerTag.NamespaceDirective_combinators); node.combinators?.accept(this); + _expectMarker(MarkerTag.NamespaceDirective_configurations); node.configurations?.accept(this); + _expectMarker(MarkerTag.NamespaceDirective_uriBasedDirective); _uriBasedDirective(node); + _expectMarker(MarkerTag.NamespaceDirective_end); } Element _nextElement() { @@ -1149,8 +1478,11 @@ resolution.byteOffset: ${_resolution.byteOffset} element.setCodeRange(summaryData.codeOffset, summaryData.codeLength); } + _expectMarker(MarkerTag.NormalFormalParameter_metadata); node.metadata?.accept(this); + _expectMarker(MarkerTag.NormalFormalParameter_formalParameter); _formalParameter(node); + _expectMarker(MarkerTag.NormalFormalParameter_end); } /// TODO(scheglov) also enclosing elements @@ -1204,9 +1536,16 @@ resolution.byteOffset: ${_resolution.byteOffset} } } + void _typeAlias(TypeAlias node) { + _namedCompilationUnitMember(node); + } + void _uriBasedDirective(UriBasedDirective node) { - _directive(node); + _expectMarker(MarkerTag.UriBasedDirective_uri); node.uri.accept(this); + _expectMarker(MarkerTag.UriBasedDirective_directive); + _directive(node); + _expectMarker(MarkerTag.UriBasedDirective_end); } /// TODO(scheglov) Remove after fixing http://dartbug.com/44449 diff --git a/pkg/analyzer/lib/src/summary2/ast_binary_flags.dart b/pkg/analyzer/lib/src/summary2/ast_binary_flags.dart index 9bdefc7c61978..4c23e9fb2018d 100644 --- a/pkg/analyzer/lib/src/summary2/ast_binary_flags.dart +++ b/pkg/analyzer/lib/src/summary2/ast_binary_flags.dart @@ -4,6 +4,17 @@ import 'package:analyzer/dart/ast/ast.dart'; +/// When this option enabled, when we write AST and resolution, we write +/// into markers into the resolution stream, so when we apply resolution +/// to AST, we can be more confident that we are reading resolution data +/// that is expected to the AST node to which resolution is applied. +/// +/// This might help us to track if we have a bug and think that some resolution +/// data can be applied (because its signature is the same), when actually +/// AST changed in ways that should make resolution incompatible (and so +/// the resolution signature should have been different). +bool enableDebugResolutionMarkers = false; + class AstBinaryFlags { static final Map _typeBits = {}; diff --git a/pkg/analyzer/lib/src/summary2/ast_binary_tag.dart b/pkg/analyzer/lib/src/summary2/ast_binary_tag.dart index 0c19a9e269651..cf220f20dd0b5 100644 --- a/pkg/analyzer/lib/src/summary2/ast_binary_tag.dart +++ b/pkg/analyzer/lib/src/summary2/ast_binary_tag.dart @@ -2,6 +2,324 @@ // 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. +/// When debugging, these tags are written in resolution information to +/// mark positions where we expect resolution for specific kinds of nodes. +/// This might help us to be more confident that we are reading resolution +/// data that corresponds to AST, and find places where they start +/// diverging. +enum MarkerTag { + AnnotatedNode_metadata, + AnnotatedNode_end, + Annotation_name, + Annotation_constructorName, + Annotation_arguments, + Annotation_element, + ArgumentList_arguments, + ArgumentList_end, + AsExpression_expression, + AsExpression_type, + AsExpression_expression2, + AsExpression_end, + Expression_staticType, + AssertInitializer_condition, + AssertInitializer_message, + AssertInitializer_end, + AssignmentExpression_leftHandSide, + AssignmentExpression_rightHandSide, + AssignmentExpression_staticElement, + AssignmentExpression_readElement, + AssignmentExpression_readType, + AssignmentExpression_writeElement, + AssignmentExpression_writeType, + AssignmentExpression_expression, + AssignmentExpression_end, + BinaryExpression_leftOperand, + BinaryExpression_rightOperand, + BinaryExpression_staticElement, + BinaryExpression_expression, + BinaryExpression_end, + CascadeExpression_target, + CascadeExpression_cascadeSections, + CascadeExpression_end, + ClassDeclaration_typeParameters, + ClassDeclaration_extendsClause, + ClassDeclaration_withClause, + ClassDeclaration_implementsClause, + ClassDeclaration_nativeClause, + ClassDeclaration_namedCompilationUnitMember, + ClassDeclaration_end, + ClassMember_declaration, + ClassMember_end, + ClassTypeAlias_typeParameters, + ClassTypeAlias_superclass, + ClassTypeAlias_withClause, + ClassTypeAlias_implementsClause, + ClassTypeAlias_typeAlias, + ClassTypeAlias_end, + ConditionalExpression_condition, + ConditionalExpression_thenExpression, + ConditionalExpression_elseExpression, + Configuration_name, + Configuration_value, + Configuration_uri, + Configuration_end, + ConstructorDeclaration_returnType, + ConstructorDeclaration_parameters, + ConstructorDeclaration_initializers, + ConstructorDeclaration_redirectedConstructor, + ConstructorDeclaration_classMember, + ConstructorDeclaration_end, + ConstructorFieldInitializer_fieldName, + ConstructorFieldInitializer_expression, + ConstructorFieldInitializer_end, + ConstructorName_type, + ConstructorName_name, + ConstructorName_staticElement, + ConstructorName_end, + DeclaredIdentifier_type, + DeclaredIdentifier_identifier, + DeclaredIdentifier_declaration, + DeclaredIdentifier_end, + DefaultFormalParameter_parameter, + DefaultFormalParameter_defaultValue, + DefaultFormalParameter_end, + EnumConstantDeclaration_name, + EnumConstantDeclaration_declaration, + EnumConstantDeclaration_end, + EnumDeclaration_constants, + EnumDeclaration_namedCompilationUnitMember, + EnumDeclaration_end, + ExportDirective_namespaceDirective, + ExportDirective_exportedLibrary, + ExportDirective_end, + ExtendsClause_superclass, + ExtendsClause_end, + ExtensionDeclaration_typeParameters, + ExtensionDeclaration_extendedType, + ExtensionDeclaration_compilationUnitMember, + ExtensionDeclaration_end, + ExtensionOverride_extensionName, + ExtensionOverride_typeArguments, + ExtensionOverride_argumentList, + ExtensionOverride_extendedType, + ExtensionOverride_end, + FieldDeclaration_fields, + FieldDeclaration_classMember, + FieldDeclaration_end, + FieldFormalParameter_typeParameters, + FieldFormalParameter_type, + FieldFormalParameter_parameters, + FieldFormalParameter_normalFormalParameter, + FieldFormalParameter_end, + ForEachParts_iterable, + ForEachParts_forLoopParts, + ForEachParts_end, + ForEachPartsWithDeclaration_loopVariable, + ForEachPartsWithDeclaration_forEachParts, + ForEachPartsWithDeclaration_end, + ForElement_body, + ForElement_forMixin, + ForElement_end, + FormalParameter_type, + ForMixin_forLoopParts, + ForParts_condition, + ForParts_updaters, + ForParts_forLoopParts, + ForParts_end, + FormalParameterList_parameters, + FormalParameterList_end, + ForPartsWithDeclarations_variables, + ForPartsWithDeclarations_forParts, + ForPartsWithDeclarations_end, + FunctionDeclaration_functionExpression, + FunctionDeclaration_returnType, + FunctionDeclaration_namedCompilationUnitMember, + FunctionDeclaration_returnTypeType, + FunctionDeclaration_end, + FunctionExpression_typeParameters, + FunctionExpression_parameters, + FunctionExpression_end, + FunctionExpressionInvocation_function, + FunctionExpressionInvocation_invocationExpression, + FunctionExpressionInvocation_end, + FunctionTypeAlias_typeParameters, + FunctionTypeAlias_returnType, + FunctionTypeAlias_parameters, + FunctionTypeAlias_typeAlias, + FunctionTypeAlias_returnTypeType, + FunctionTypeAlias_flags, + FunctionTypeAlias_end, + FunctionTypedFormalParameter_typeParameters, + FunctionTypedFormalParameter_returnType, + FunctionTypedFormalParameter_parameters, + FunctionTypedFormalParameter_normalFormalParameter, + FunctionTypedFormalParameter_end, + GenericFunctionType_typeParameters, + GenericFunctionType_returnType, + GenericFunctionType_parameters, + GenericFunctionType_type, + GenericFunctionType_end, + GenericTypeAlias_typeParameters, + GenericTypeAlias_type, + GenericTypeAlias_typeAlias, + GenericTypeAlias_flags, + GenericTypeAlias_end, + IfElement_condition, + IfElement_thenElement, + IfElement_elseElement, + IfElement_end, + ImplementsClause_interfaces, + ImplementsClause_end, + ImportDirective_namespaceDirective, + ImportDirective_importedLibrary, + ImportDirective_end, + IndexExpression_target, + IndexExpression_index, + IndexExpression_staticElement, + IndexExpression_expression, + IndexExpression_end, + InstanceCreationExpression_constructorName, + InstanceCreationExpression_argumentList, + InstanceCreationExpression_expression, + InstanceCreationExpression_end, + IsExpression_expression, + IsExpression_type, + IsExpression_expression2, + IsExpression_end, + InvocationExpression_typeArguments, + InvocationExpression_argumentList, + InvocationExpression_expression, + InvocationExpression_end, + ListLiteral_typeArguments, + ListLiteral_elements, + ListLiteral_expression, + ListLiteral_end, + MapLiteralEntry_key, + MapLiteralEntry_value, + MethodDeclaration_typeParameters, + MethodDeclaration_returnType, + MethodDeclaration_parameters, + MethodDeclaration_classMember, + MethodDeclaration_returnTypeType, + MethodDeclaration_inferenceError, + MethodDeclaration_flags, + MethodDeclaration_end, + MethodInvocation_target, + MethodInvocation_methodName, + MethodInvocation_invocationExpression, + MethodInvocation_end, + MixinDeclaration_typeParameters, + MixinDeclaration_onClause, + MixinDeclaration_implementsClause, + MixinDeclaration_namedCompilationUnitMember, + MixinDeclaration_end, + NamedExpression_expression, + NamedExpression_end, + NamespaceDirective_combinators, + NamespaceDirective_configurations, + NamespaceDirective_uriBasedDirective, + NamespaceDirective_end, + NativeClause_name, + NativeClause_end, + NormalFormalParameter_metadata, + NormalFormalParameter_formalParameter, + NormalFormalParameter_end, + OnClause_superclassConstraints, + OnClause_end, + ParenthesizedExpression_expression, + ParenthesizedExpression_expression2, + ParenthesizedExpression_end, + PartOfDirective_libraryName, + PartOfDirective_uri, + PartOfDirective_directive, + PartOfDirective_end, + PostfixExpression_operand, + PostfixExpression_staticElement, + PostfixExpression_readElement, + PostfixExpression_readType, + PostfixExpression_writeElement, + PostfixExpression_writeType, + PostfixExpression_expression, + PostfixExpression_end, + PrefixedIdentifier_prefix, + PrefixedIdentifier_identifier, + PrefixedIdentifier_expression, + PrefixedIdentifier_end, + PrefixExpression_operand, + PrefixExpression_staticElement, + PrefixExpression_readElement, + PrefixExpression_readType, + PrefixExpression_writeElement, + PrefixExpression_writeType, + PrefixExpression_expression, + PrefixExpression_end, + PropertyAccess_target, + PropertyAccess_propertyName, + PropertyAccess_expression, + PropertyAccess_end, + RedirectingConstructorInvocation_constructorName, + RedirectingConstructorInvocation_argumentList, + RedirectingConstructorInvocation_staticElement, + RedirectingConstructorInvocation_end, + SetOrMapLiteral_flags, + SetOrMapLiteral_typeArguments, + SetOrMapLiteral_elements, + SetOrMapLiteral_expression, + SetOrMapLiteral_end, + SimpleFormalParameter_type, + SimpleFormalParameter_normalFormalParameter, + SimpleFormalParameter_flags, + SimpleFormalParameter_end, + SimpleIdentifier_staticElement, + SimpleIdentifier_expression, + SimpleIdentifier_end, + SpreadElement_expression, + SpreadElement_end, + StringInterpolation_elements, + StringInterpolation_end, + SuperConstructorInvocation_constructorName, + SuperConstructorInvocation_argumentList, + SuperConstructorInvocation_staticElement, + SuperConstructorInvocation_end, + SuperExpression_expression, + SuperExpression_end, + ThisExpression_expression, + ThisExpression_end, + ThrowExpression_expression, + ThrowExpression_expression2, + ThrowExpression_end, + TopLevelVariableDeclaration_variables, + TopLevelVariableDeclaration_compilationUnitMember, + TopLevelVariableDeclaration_end, + TypeArgumentList_arguments, + TypeArgumentList_end, + TypeName_name, + TypeName_typeArguments, + TypeName_type, + TypeName_end, + TypeParameter_bound, + TypeParameter_declaration, + TypeParameter_variance, + TypeParameter_defaultType, + TypeParameter_end, + TypeParameterList_typeParameters, + TypeParameterList_end, + UriBasedDirective_uri, + UriBasedDirective_directive, + UriBasedDirective_end, + VariableDeclaration_type, + VariableDeclaration_inferenceError, + VariableDeclaration_inheritsCovariant, + VariableDeclaration_initializer, + VariableDeclaration_end, + VariableDeclarationList_type, + VariableDeclarationList_variables, + VariableDeclarationList_annotatedNode, + VariableDeclarationList_end, + WithClause_mixinTypes, + WithClause_end, +} + /// A `MethodInvocation` in unresolved AST might be rewritten later as /// another kinds of AST node. We store this rewrite with resolution data. class MethodInvocationRewriteTag { diff --git a/pkg/analyzer/lib/src/summary2/ast_binary_writer.dart b/pkg/analyzer/lib/src/summary2/ast_binary_writer.dart index fed03d867464a..6f7f8a98fd95d 100644 --- a/pkg/analyzer/lib/src/summary2/ast_binary_writer.dart +++ b/pkg/analyzer/lib/src/summary2/ast_binary_writer.dart @@ -61,9 +61,12 @@ class AstBinaryWriter extends ThrowingAstVisitor { void visitAnnotation(Annotation node) { _writeByte(Tag.Annotation); + _writeMarker(MarkerTag.Annotation_name); _writeOptionalNode(node.name); + _writeMarker(MarkerTag.Annotation_constructorName); _writeOptionalNode(node.constructorName); + _writeMarker(MarkerTag.Annotation_arguments); var arguments = node.arguments; if (arguments != null) { if (!arguments.arguments.every(_isSerializableExpression)) { @@ -73,6 +76,7 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeOptionalNode(arguments); if (_shouldWriteResolution) { + _writeMarker(MarkerTag.Annotation_element); _resolutionSink.writeElement(node.element); } } @@ -80,29 +84,44 @@ class AstBinaryWriter extends ThrowingAstVisitor { @override void visitArgumentList(ArgumentList node) { _writeByte(Tag.ArgumentList); + _writeMarker(MarkerTag.ArgumentList_arguments); _writeNodeList(node.arguments); + _writeMarker(MarkerTag.ArgumentList_end); } @override void visitAsExpression(AsExpression node) { _writeByte(Tag.AsExpression); + + _writeMarker(MarkerTag.AsExpression_expression); _writeNode(node.expression); + + _writeMarker(MarkerTag.AsExpression_type); _writeNode(node.type); + + _writeMarker(MarkerTag.AsExpression_expression2); _storeExpression(node); + + _writeMarker(MarkerTag.AsExpression_end); } @override void visitAssertInitializer(AssertInitializer node) { _writeByte(Tag.AssertInitializer); + _writeMarker(MarkerTag.AssertInitializer_condition); _writeNode(node.condition); + _writeMarker(MarkerTag.AssertInitializer_message); _writeOptionalNode(node.message); + _writeMarker(MarkerTag.AssertInitializer_end); } @override void visitAssignmentExpression(AssignmentExpression node) { _writeByte(Tag.AssignmentExpression); + _writeMarker(MarkerTag.AssignmentExpression_leftHandSide); _writeNode(node.leftHandSide); + _writeMarker(MarkerTag.AssignmentExpression_rightHandSide); _writeNode(node.rightHandSide); var operatorToken = node.operator.type; @@ -110,20 +129,29 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeByte(binaryToken.index); if (_shouldWriteResolution) { + _writeMarker(MarkerTag.AssignmentExpression_staticElement); _resolutionSink.writeElement(node.staticElement); + _writeMarker(MarkerTag.AssignmentExpression_readElement); _resolutionSink.writeElement(node.readElement); + _writeMarker(MarkerTag.AssignmentExpression_readType); _resolutionSink.writeType(node.readType); + _writeMarker(MarkerTag.AssignmentExpression_writeElement); _resolutionSink.writeElement(node.writeElement); + _writeMarker(MarkerTag.AssignmentExpression_writeType); _resolutionSink.writeType(node.writeType); } + _writeMarker(MarkerTag.AssignmentExpression_expression); _storeExpression(node); + _writeMarker(MarkerTag.AssignmentExpression_end); } @override void visitBinaryExpression(BinaryExpression node) { _writeByte(Tag.BinaryExpression); + _writeMarker(MarkerTag.BinaryExpression_leftOperand); _writeNode(node.leftOperand); + _writeMarker(MarkerTag.BinaryExpression_rightOperand); _writeNode(node.rightOperand); var operatorToken = node.operator.type; @@ -131,9 +159,12 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeByte(binaryToken.index); if (_shouldWriteResolution) { + _writeMarker(MarkerTag.BinaryExpression_staticElement); _resolutionSink.writeElement(node.staticElement); - _resolutionSink.writeType(node.staticType); } + _writeMarker(MarkerTag.BinaryExpression_expression); + _storeExpression(node); + _writeMarker(MarkerTag.BinaryExpression_end); } @override @@ -141,15 +172,18 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeByte(Tag.BooleanLiteral); _writeByte(node.value ? 1 : 0); if (_shouldWriteResolution) { - _resolutionSink.writeType(node.staticType); + _storeExpression(node); } } @override void visitCascadeExpression(CascadeExpression node) { _writeByte(Tag.CascadeExpression); + _writeMarker(MarkerTag.CascadeExpression_target); _writeNode(node.target); + _writeMarker(MarkerTag.CascadeExpression_cascadeSections); _writeNodeList(node.cascadeSections); + _writeMarker(MarkerTag.CascadeExpression_end); } @override @@ -182,12 +216,19 @@ class AstBinaryWriter extends ThrowingAstVisitor { _pushScopeTypeParameters(node.typeParameters); + _writeMarker(MarkerTag.ClassDeclaration_typeParameters); _writeOptionalNode(node.typeParameters); + _writeMarker(MarkerTag.ClassDeclaration_extendsClause); _writeOptionalNode(node.extendsClause); + _writeMarker(MarkerTag.ClassDeclaration_withClause); _writeOptionalNode(node.withClause); + _writeMarker(MarkerTag.ClassDeclaration_implementsClause); _writeOptionalNode(node.implementsClause); + _writeMarker(MarkerTag.ClassDeclaration_nativeClause); _writeOptionalNode(node.nativeClause); + _writeMarker(MarkerTag.ClassDeclaration_namedCompilationUnitMember); _storeNamedCompilationUnitMember(node); + _writeMarker(MarkerTag.ClassDeclaration_end); _writeUInt30(resolutionIndex); _classMemberIndexItems.clear(); @@ -236,11 +277,17 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeInformativeUint30(node.offset); _writeInformativeUint30(node.length); _pushScopeTypeParameters(node.typeParameters); + _writeMarker(MarkerTag.ClassTypeAlias_typeParameters); _writeOptionalNode(node.typeParameters); + _writeMarker(MarkerTag.ClassTypeAlias_superclass); _writeNode(node.superclass); + _writeMarker(MarkerTag.ClassTypeAlias_withClause); _writeNode(node.withClause); + _writeMarker(MarkerTag.ClassTypeAlias_implementsClause); _writeOptionalNode(node.implementsClause); + _writeMarker(MarkerTag.ClassTypeAlias_typeAlias); _storeTypeAlias(node); + _writeMarker(MarkerTag.ClassTypeAlias_end); _writeDocumentationCommentString(node.documentationComment); _writeUInt30(resolutionIndex); if (_shouldWriteResolution) { @@ -264,8 +311,11 @@ class AstBinaryWriter extends ThrowingAstVisitor { @override void visitConditionalExpression(ConditionalExpression node) { _writeByte(Tag.ConditionalExpression); + _writeMarker(MarkerTag.ConditionalExpression_condition); _writeNode(node.condition); + _writeMarker(MarkerTag.ConditionalExpression_thenExpression); _writeNode(node.thenExpression); + _writeMarker(MarkerTag.ConditionalExpression_elseExpression); _writeNode(node.elseExpression); _storeExpression(node); } @@ -280,9 +330,13 @@ class AstBinaryWriter extends ThrowingAstVisitor { ), ); + _writeMarker(MarkerTag.Configuration_name); _writeNode(node.name); + _writeMarker(MarkerTag.Configuration_value); _writeOptionalNode(node.value); + _writeMarker(MarkerTag.Configuration_uri); _writeNode(node.uri); + _writeMarker(MarkerTag.Configuration_end); } @override @@ -314,11 +368,13 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeDocumentationCommentString(node.documentationComment); var resolutionIndex = _getNextResolutionIndex(); + _writeMarker(MarkerTag.ConstructorDeclaration_returnType); _writeNode(node.returnType); if (node.period != null) { _writeInformativeUint30(node.period.offset); _writeDeclarationName(node.name); } + _writeMarker(MarkerTag.ConstructorDeclaration_parameters); _writeNode(node.parameters); if (_shouldWriteResolution) { @@ -330,6 +386,7 @@ class AstBinaryWriter extends ThrowingAstVisitor { // TODO(scheglov) Not nice, we skip both resolution and AST. // But eventually we want to store full AST, and partial resolution. + _writeMarker(MarkerTag.ConstructorDeclaration_initializers); if (node.constKeyword != null) { _writeNodeList(node.initializers); } else { @@ -340,8 +397,11 @@ class AstBinaryWriter extends ThrowingAstVisitor { _resolutionSink.localElements.popScope(); } + _writeMarker(MarkerTag.ConstructorDeclaration_redirectedConstructor); _writeOptionalNode(node.redirectedConstructor); + _writeMarker(MarkerTag.ConstructorDeclaration_classMember); _storeClassMember(node); + _writeMarker(MarkerTag.ConstructorDeclaration_end); _writeUInt30(resolutionIndex); } @@ -355,9 +415,11 @@ class AstBinaryWriter extends ThrowingAstVisitor { ), ); + _writeMarker(MarkerTag.ConstructorFieldInitializer_fieldName); _writeNode(node.fieldName); + _writeMarker(MarkerTag.ConstructorFieldInitializer_expression); _writeNode(node.expression); - _storeConstructorInitializer(node); + _writeMarker(MarkerTag.ConstructorFieldInitializer_end); } @override @@ -372,12 +434,17 @@ class AstBinaryWriter extends ThrowingAstVisitor { _resolutionSink.writeByte(node.name != null ? 1 : 0); } + _writeMarker(MarkerTag.ConstructorName_type); _writeNode(node.type); + _writeMarker(MarkerTag.ConstructorName_name); _writeOptionalNode(node.name); if (_shouldWriteResolution) { + _writeMarker(MarkerTag.ConstructorName_staticElement); _resolutionSink.writeElement(node.staticElement); } + + _writeMarker(MarkerTag.ConstructorName_end); } @override @@ -390,9 +457,13 @@ class AstBinaryWriter extends ThrowingAstVisitor { isVar: node.keyword?.keyword == Keyword.VAR, ), ); + _writeMarker(MarkerTag.DeclaredIdentifier_type); _writeOptionalNode(node.type); + _writeMarker(MarkerTag.DeclaredIdentifier_identifier); _writeDeclarationName(node.identifier); + _writeMarker(MarkerTag.DeclaredIdentifier_declaration); _storeDeclaration(node); + _writeMarker(MarkerTag.DeclaredIdentifier_end); } @override @@ -410,13 +481,16 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeInformativeUint30(node.offset); _writeInformativeUint30(node.length); + _writeMarker(MarkerTag.DefaultFormalParameter_parameter); _writeNode(node.parameter); var defaultValue = node.defaultValue; if (!_isSerializableExpression(defaultValue)) { defaultValue = null; } + _writeMarker(MarkerTag.DefaultFormalParameter_defaultValue); _writeOptionalNode(defaultValue); + _writeMarker(MarkerTag.DefaultFormalParameter_end); } @override @@ -439,8 +513,11 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeInformativeUint30(node.length); _writeDocumentationCommentString(node.documentationComment); + _writeMarker(MarkerTag.EnumConstantDeclaration_name); _writeDeclarationName(node.name); + _writeMarker(MarkerTag.EnumConstantDeclaration_declaration); _storeDeclaration(node); + _writeMarker(MarkerTag.EnumConstantDeclaration_end); } @override @@ -460,8 +537,11 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeInformativeUint30(node.length); _writeDocumentationCommentString(node.documentationComment); + _writeMarker(MarkerTag.EnumDeclaration_constants); _writeNodeList(node.constants); + _writeMarker(MarkerTag.EnumDeclaration_namedCompilationUnitMember); _storeNamedCompilationUnitMember(node); + _writeMarker(MarkerTag.EnumDeclaration_end); _writeUInt30(resolutionIndex); } @@ -470,20 +550,26 @@ class AstBinaryWriter extends ThrowingAstVisitor { var resolutionIndex = _getNextResolutionIndex(); _writeByte(Tag.ExportDirective); + _writeMarker(MarkerTag.ExportDirective_namespaceDirective); _storeNamespaceDirective(node); _writeUInt30(resolutionIndex); if (_shouldWriteResolution) { + _writeMarker(MarkerTag.ExportDirective_exportedLibrary); _resolutionSink.writeElement( (node.element as ExportElementImpl).exportedLibrary, ); } + + _writeMarker(MarkerTag.ExportDirective_end); } @override void visitExtendsClause(ExtendsClause node) { _writeByte(Tag.ExtendsClause); + _writeMarker(MarkerTag.ExtendsClause_superclass); _writeNode(node.superclass); + _writeMarker(MarkerTag.ExtendsClause_end); } @override @@ -498,10 +584,14 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeDocumentationCommentString(node.documentationComment); _pushScopeTypeParameters(node.typeParameters); + _writeMarker(MarkerTag.ExtensionDeclaration_typeParameters); _writeOptionalNode(node.typeParameters); + _writeMarker(MarkerTag.ExtensionDeclaration_extendedType); _writeNode(node.extendedType); _writeOptionalDeclarationName(node.name); + _writeMarker(MarkerTag.ExtensionDeclaration_compilationUnitMember); _storeCompilationUnitMember(node); + _writeMarker(MarkerTag.ExtensionDeclaration_end); _writeUInt30(resolutionIndex); _classMemberIndexItems.clear(); @@ -537,10 +627,15 @@ class AstBinaryWriter extends ThrowingAstVisitor { _resolutionSink.writeByte(MethodInvocationRewriteTag.extensionOverride); } + _writeMarker(MarkerTag.ExtensionOverride_extensionName); _writeNode(node.extensionName); + _writeMarker(MarkerTag.ExtensionOverride_typeArguments); _writeOptionalNode(node.typeArguments); + _writeMarker(MarkerTag.ExtensionOverride_argumentList); _writeNode(node.argumentList); + _writeMarker(MarkerTag.ExtensionOverride_extendedType); _resolutionSink.writeType(node.extendedType); + _writeMarker(MarkerTag.ExtensionOverride_end); // TODO(scheglov) typeArgumentTypes? } @@ -572,12 +667,15 @@ class AstBinaryWriter extends ThrowingAstVisitor { _shouldStoreVariableInitializers = node.fields.isConst || _hasConstConstructor && node.fields.isFinal && !node.isStatic; try { + _writeMarker(MarkerTag.FieldDeclaration_fields); _writeNode(node.fields); } finally { _shouldStoreVariableInitializers = false; } + _writeMarker(MarkerTag.FieldDeclaration_classMember); _storeClassMember(node); + _writeMarker(MarkerTag.FieldDeclaration_end); _writeUInt30(resolutionIndex); } @@ -587,14 +685,19 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeByte(Tag.FieldFormalParameter); _pushScopeTypeParameters(node.typeParameters); + _writeMarker(MarkerTag.FieldFormalParameter_typeParameters); _writeOptionalNode(node.typeParameters); + _writeMarker(MarkerTag.FieldFormalParameter_type); _writeOptionalNode(node.type); + _writeMarker(MarkerTag.FieldFormalParameter_parameters); _writeOptionalNode(node.parameters); + _writeMarker(MarkerTag.FieldFormalParameter_normalFormalParameter); _storeNormalFormalParameter( node, node.keyword, hasQuestion: node.question != null, ); + _writeMarker(MarkerTag.FieldFormalParameter_end); if (_shouldWriteResolution) { _resolutionSink.localElements.popScope(); @@ -604,15 +707,21 @@ class AstBinaryWriter extends ThrowingAstVisitor { @override void visitForEachPartsWithDeclaration(ForEachPartsWithDeclaration node) { _writeByte(Tag.ForEachPartsWithDeclaration); + _writeMarker(MarkerTag.ForEachPartsWithDeclaration_loopVariable); _writeNode(node.loopVariable); + _writeMarker(MarkerTag.ForEachPartsWithDeclaration_forEachParts); _storeForEachParts(node); + _writeMarker(MarkerTag.ForEachPartsWithDeclaration_end); } @override void visitForElement(ForElement node) { _writeByte(Tag.ForElement); + _writeMarker(MarkerTag.ForElement_body); _writeNode(node.body); + _writeMarker(MarkerTag.ForElement_forMixin); _storeForMixin(node as ForElementImpl); + _writeMarker(MarkerTag.ForElement_end); } @override @@ -627,14 +736,19 @@ class AstBinaryWriter extends ThrowingAstVisitor { ), ); + _writeMarker(MarkerTag.FormalParameterList_parameters); _writeNodeList(node.parameters); + _writeMarker(MarkerTag.FormalParameterList_end); } @override void visitForPartsWithDeclarations(ForPartsWithDeclarations node) { _writeByte(Tag.ForPartsWithDeclarations); + _writeMarker(MarkerTag.ForPartsWithDeclarations_variables); _writeNode(node.variables); + _writeMarker(MarkerTag.ForPartsWithDeclarations_forParts); _storeForParts(node); + _writeMarker(MarkerTag.ForPartsWithDeclarations_end); } @override @@ -672,15 +786,21 @@ class AstBinaryWriter extends ThrowingAstVisitor { _pushScopeTypeParameters(node.functionExpression.typeParameters); + _writeMarker(MarkerTag.FunctionDeclaration_functionExpression); _writeNode(node.functionExpression); + _writeMarker(MarkerTag.FunctionDeclaration_returnType); _writeOptionalNode(node.returnType); + _writeMarker(MarkerTag.FunctionDeclaration_namedCompilationUnitMember); _storeNamedCompilationUnitMember(node); if (_shouldWriteResolution) { + _writeMarker(MarkerTag.FunctionDeclaration_returnTypeType); _writeActualReturnType(node.declaredElement.returnType); _resolutionSink.localElements.popScope(); } + _writeMarker(MarkerTag.FunctionDeclaration_end); + _writeUInt30(resolutionIndex); } @@ -696,8 +816,11 @@ class AstBinaryWriter extends ThrowingAstVisitor { ), ); + _writeMarker(MarkerTag.FunctionExpression_typeParameters); _writeOptionalNode(node.typeParameters); + _writeMarker(MarkerTag.FunctionExpression_parameters); _writeOptionalNode(node.parameters); + _writeMarker(MarkerTag.FunctionExpression_end); } @override @@ -709,8 +832,11 @@ class AstBinaryWriter extends ThrowingAstVisitor { .writeByte(MethodInvocationRewriteTag.functionExpressionInvocation); } + _writeMarker(MarkerTag.FunctionExpressionInvocation_function); _writeNode(node.function); + _writeMarker(MarkerTag.FunctionExpressionInvocation_invocationExpression); _storeInvocationExpression(node); + _writeMarker(MarkerTag.FunctionExpressionInvocation_end); } @override @@ -734,22 +860,30 @@ class AstBinaryWriter extends ThrowingAstVisitor { _pushScopeTypeParameters(node.typeParameters); + _writeMarker(MarkerTag.FunctionTypeAlias_typeParameters); _writeOptionalNode(node.typeParameters); + _writeMarker(MarkerTag.FunctionTypeAlias_returnType); _writeOptionalNode(node.returnType); + _writeMarker(MarkerTag.FunctionTypeAlias_parameters); _writeNode(node.parameters); + _writeMarker(MarkerTag.FunctionTypeAlias_typeAlias); _storeTypeAlias(node); if (_shouldWriteResolution) { var element = node.declaredElement as FunctionTypeAliasElementImpl; + _writeMarker(MarkerTag.FunctionTypeAlias_returnTypeType); _writeActualReturnType(element.function.returnType); // TODO(scheglov) pack into one byte + _writeMarker(MarkerTag.FunctionTypeAlias_flags); _resolutionSink.writeByte(element.isSimplyBounded ? 1 : 0); _resolutionSink.writeByte(element.hasSelfReference ? 1 : 0); _resolutionSink.localElements.popScope(); } + _writeMarker(MarkerTag.FunctionTypeAlias_end); + _writeUInt30(resolutionIndex); } @@ -758,10 +892,15 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeByte(Tag.FunctionTypedFormalParameter); _pushScopeTypeParameters(node.typeParameters); + _writeMarker(MarkerTag.FunctionTypedFormalParameter_typeParameters); _writeOptionalNode(node.typeParameters); + _writeMarker(MarkerTag.FunctionTypedFormalParameter_returnType); _writeOptionalNode(node.returnType); + _writeMarker(MarkerTag.FunctionTypedFormalParameter_parameters); _writeNode(node.parameters); + _writeMarker(MarkerTag.FunctionTypedFormalParameter_normalFormalParameter); _storeNormalFormalParameter(node, null); + _writeMarker(MarkerTag.FunctionTypedFormalParameter_end); if (_shouldWriteResolution) { _resolutionSink.localElements.popScope(); @@ -780,14 +919,20 @@ class AstBinaryWriter extends ThrowingAstVisitor { _pushScopeTypeParameters(node.typeParameters); + _writeMarker(MarkerTag.GenericFunctionType_typeParameters); _writeOptionalNode(node.typeParameters); + _writeMarker(MarkerTag.GenericFunctionType_returnType); _writeOptionalNode(node.returnType); + _writeMarker(MarkerTag.GenericFunctionType_parameters); _writeNode(node.parameters); if (_shouldWriteResolution) { + _writeMarker(MarkerTag.GenericFunctionType_type); _resolutionSink.writeType(node.type); _resolutionSink.localElements.popScope(); } + + _writeMarker(MarkerTag.GenericFunctionType_end); } @override @@ -810,18 +955,24 @@ class AstBinaryWriter extends ThrowingAstVisitor { _pushScopeTypeParameters(node.typeParameters); + _writeMarker(MarkerTag.GenericTypeAlias_typeParameters); _writeOptionalNode(node.typeParameters); + _writeMarker(MarkerTag.GenericTypeAlias_type); _writeOptionalNode(node.type); + _writeMarker(MarkerTag.GenericTypeAlias_typeAlias); _storeTypeAlias(node); if (_shouldWriteResolution) { var element = node.declaredElement as TypeAliasElementImpl; // TODO(scheglov) pack into one byte + _writeMarker(MarkerTag.GenericTypeAlias_flags); _resolutionSink.writeByte(element.isSimplyBounded ? 1 : 0); _resolutionSink.writeByte(element.hasSelfReference ? 1 : 0); _resolutionSink.localElements.popScope(); } + _writeMarker(MarkerTag.GenericTypeAlias_end); + _writeUInt30(resolutionIndex); } @@ -835,15 +986,21 @@ class AstBinaryWriter extends ThrowingAstVisitor { @override void visitIfElement(IfElement node) { _writeByte(Tag.IfElement); + _writeMarker(MarkerTag.IfElement_condition); _writeNode(node.condition); + _writeMarker(MarkerTag.IfElement_thenElement); _writeNode(node.thenElement); + _writeMarker(MarkerTag.IfElement_elseElement); _writeOptionalNode(node.elseElement); + _writeMarker(MarkerTag.IfElement_end); } @override void visitImplementsClause(ImplementsClause node) { _writeByte(Tag.ImplementsClause); + _writeMarker(MarkerTag.ImplementsClause_interfaces); _writeNodeList(node.interfaces); + _writeMarker(MarkerTag.ImplementsClause_end); } @override @@ -865,13 +1022,17 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeInformativeUint30(prefix.offset); } + _writeMarker(MarkerTag.ImportDirective_namespaceDirective); _storeNamespaceDirective(node); _writeUInt30(resolutionIndex); if (_shouldWriteResolution) { var element = node.element as ImportElementImpl; + _writeMarker(MarkerTag.ImportDirective_importedLibrary); _resolutionSink.writeElement(element.importedLibrary); } + + _writeMarker(MarkerTag.ImportDirective_end); } @override @@ -883,12 +1044,17 @@ class AstBinaryWriter extends ThrowingAstVisitor { hasQuestion: node.question != null, ), ); + _writeMarker(MarkerTag.IndexExpression_target); _writeOptionalNode(node.target); + _writeMarker(MarkerTag.IndexExpression_index); _writeNode(node.index); if (_shouldWriteResolution) { + _writeMarker(MarkerTag.IndexExpression_staticElement); _resolutionSink.writeElement(node.staticElement); } + _writeMarker(MarkerTag.IndexExpression_expression); _storeExpression(node); + _writeMarker(MarkerTag.IndexExpression_end); } @override @@ -914,9 +1080,13 @@ class AstBinaryWriter extends ThrowingAstVisitor { ), ); + _writeMarker(MarkerTag.InstanceCreationExpression_constructorName); _writeNode(node.constructorName); + _writeMarker(MarkerTag.InstanceCreationExpression_argumentList); _writeNode(node.argumentList); + _writeMarker(MarkerTag.InstanceCreationExpression_expression); _storeExpression(node); + _writeMarker(MarkerTag.InstanceCreationExpression_end); } @override @@ -948,10 +1118,8 @@ class AstBinaryWriter extends ThrowingAstVisitor { } } - if (_shouldWriteResolution) { - // TODO(scheglov) Dont write type, AKA separate true `int` and `double`? - _resolutionSink.writeType(node.staticType); - } + // TODO(scheglov) Dont write type, AKA separate true `int` and `double`? + _storeExpression(node); } @override @@ -980,9 +1148,13 @@ class AstBinaryWriter extends ThrowingAstVisitor { hasNot: node.notOperator != null, ), ); + _writeMarker(MarkerTag.IsExpression_expression); _writeNode(node.expression); + _writeMarker(MarkerTag.IsExpression_type); _writeNode(node.type); + _writeMarker(MarkerTag.IsExpression_expression2); _storeExpression(node); + _writeMarker(MarkerTag.IsExpression_end); } @override @@ -1009,16 +1181,22 @@ class AstBinaryWriter extends ThrowingAstVisitor { ), ); + _writeMarker(MarkerTag.ListLiteral_typeArguments); _writeOptionalNode(node.typeArguments); + _writeMarker(MarkerTag.ListLiteral_elements); _writeNodeList(node.elements); + _writeMarker(MarkerTag.ListLiteral_expression); _storeExpression(node); + _writeMarker(MarkerTag.ListLiteral_end); } @override void visitMapLiteralEntry(MapLiteralEntry node) { _writeByte(Tag.MapLiteralEntry); + _writeMarker(MarkerTag.MapLiteralEntry_key); _writeNode(node.key); + _writeMarker(MarkerTag.MapLiteralEntry_value); _writeNode(node.value); } @@ -1063,26 +1241,35 @@ class AstBinaryWriter extends ThrowingAstVisitor { _pushScopeTypeParameters(node.typeParameters); _writeDeclarationName(node.name); + _writeMarker(MarkerTag.MethodDeclaration_typeParameters); _writeOptionalNode(node.typeParameters); + _writeMarker(MarkerTag.MethodDeclaration_returnType); _writeOptionalNode(node.returnType); + _writeMarker(MarkerTag.MethodDeclaration_parameters); _writeOptionalNode(node.parameters); + _writeMarker(MarkerTag.MethodDeclaration_classMember); _storeClassMember(node); _writeUInt30(resolutionIndex); if (_shouldWriteResolution) { var element = node.declaredElement as ExecutableElementImpl; + _writeMarker(MarkerTag.MethodDeclaration_returnTypeType); _writeActualReturnType(element.returnType); + _writeMarker(MarkerTag.MethodDeclaration_inferenceError); _writeTopLevelInferenceError(element); // TODO(scheglov) move this flag into ClassElementImpl? if (element is MethodElementImpl) { + _writeMarker(MarkerTag.MethodDeclaration_flags); _resolutionSink.writeByte( element.isOperatorEqualWithParameterTypeFromObject ? 1 : 0, ); } _resolutionSink.localElements.popScope(); } + + _writeMarker(MarkerTag.MethodDeclaration_end); } @override @@ -1099,9 +1286,13 @@ class AstBinaryWriter extends ThrowingAstVisitor { hasPeriod2: node.operator?.type == TokenType.PERIOD_PERIOD, ), ); + _writeMarker(MarkerTag.MethodInvocation_target); _writeOptionalNode(node.target); + _writeMarker(MarkerTag.MethodInvocation_methodName); _writeNode(node.methodName); + _writeMarker(MarkerTag.MethodInvocation_invocationExpression); _storeInvocationExpression(node); + _writeMarker(MarkerTag.MethodInvocation_end); } @override @@ -1123,10 +1314,15 @@ class AstBinaryWriter extends ThrowingAstVisitor { _pushScopeTypeParameters(node.typeParameters); + _writeMarker(MarkerTag.MixinDeclaration_typeParameters); _writeOptionalNode(node.typeParameters); + _writeMarker(MarkerTag.MixinDeclaration_onClause); _writeOptionalNode(node.onClause); + _writeMarker(MarkerTag.MixinDeclaration_implementsClause); _writeOptionalNode(node.implementsClause); + _writeMarker(MarkerTag.MixinDeclaration_namedCompilationUnitMember); _storeNamedCompilationUnitMember(node); + _writeMarker(MarkerTag.MixinDeclaration_end); _writeUInt30(resolutionIndex); _classMemberIndexItems.clear(); @@ -1159,13 +1355,17 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeStringReference(nameNode.name); _writeInformativeUint30(nameNode.offset); + _writeMarker(MarkerTag.NamedExpression_expression); _writeNode(node.expression); + _writeMarker(MarkerTag.NamedExpression_end); } @override void visitNativeClause(NativeClause node) { _writeByte(Tag.NativeClause); + _writeMarker(MarkerTag.NativeClause_name); _writeNode(node.name); + _writeMarker(MarkerTag.NativeClause_end); } @override @@ -1176,14 +1376,19 @@ class AstBinaryWriter extends ThrowingAstVisitor { @override void visitOnClause(OnClause node) { _writeByte(Tag.OnClause); + _writeMarker(MarkerTag.OnClause_superclassConstraints); _writeNodeList(node.superclassConstraints); + _writeMarker(MarkerTag.OnClause_end); } @override void visitParenthesizedExpression(ParenthesizedExpression node) { _writeByte(Tag.ParenthesizedExpression); + _writeMarker(MarkerTag.ParenthesizedExpression_expression); _writeNode(node.expression); + _writeMarker(MarkerTag.ParenthesizedExpression_expression2); _storeExpression(node); + _writeMarker(MarkerTag.ParenthesizedExpression_end); } @override @@ -1195,15 +1400,20 @@ class AstBinaryWriter extends ThrowingAstVisitor { @override void visitPartOfDirective(PartOfDirective node) { _writeByte(Tag.PartOfDirective); + _writeMarker(MarkerTag.PartOfDirective_libraryName); _writeOptionalNode(node.libraryName); + _writeMarker(MarkerTag.PartOfDirective_uri); _writeOptionalNode(node.uri); + _writeMarker(MarkerTag.PartOfDirective_directive); _storeDirective(node); + _writeMarker(MarkerTag.PartOfDirective_end); } @override void visitPostfixExpression(PostfixExpression node) { _writeByte(Tag.PostfixExpression); + _writeMarker(MarkerTag.PostfixExpression_operand); _writeNode(node.operand); var operatorToken = node.operator.type; @@ -1211,27 +1421,36 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeByte(binaryToken.index); if (_shouldWriteResolution) { + _writeMarker(MarkerTag.PostfixExpression_staticElement); _resolutionSink.writeElement(node.staticElement); if (operatorToken.isIncrementOperator) { + _writeMarker(MarkerTag.PostfixExpression_readElement); _resolutionSink.writeElement(node.readElement); + _writeMarker(MarkerTag.PostfixExpression_readType); _resolutionSink.writeType(node.readType); + _writeMarker(MarkerTag.PostfixExpression_writeElement); _resolutionSink.writeElement(node.writeElement); + _writeMarker(MarkerTag.PostfixExpression_writeType); _resolutionSink.writeType(node.writeType); } } + _writeMarker(MarkerTag.PostfixExpression_expression); _storeExpression(node); + _writeMarker(MarkerTag.PostfixExpression_end); } @override void visitPrefixedIdentifier(PrefixedIdentifier node) { _writeByte(Tag.PrefixedIdentifier); + _writeMarker(MarkerTag.PrefixedIdentifier_prefix); _writeNode(node.prefix); + _writeMarker(MarkerTag.PrefixedIdentifier_identifier); _writeNode(node.identifier); - if (_shouldWriteResolution) { - // TODO(scheglov) In actual prefixed identifier, the type of the identifier. - _resolutionSink.writeType(node.staticType); - } + // TODO(scheglov) In actual prefixed identifier, the type of the identifier. + _writeMarker(MarkerTag.PrefixedIdentifier_expression); + _storeExpression(node); + _writeMarker(MarkerTag.PrefixedIdentifier_end); } @override @@ -1242,19 +1461,27 @@ class AstBinaryWriter extends ThrowingAstVisitor { var binaryToken = TokensWriter.astToBinaryTokenType(operatorToken); _writeByte(binaryToken.index); + _writeMarker(MarkerTag.PrefixExpression_operand); _writeNode(node.operand); if (_shouldWriteResolution) { + _writeMarker(MarkerTag.PrefixExpression_staticElement); _resolutionSink.writeElement(node.staticElement); if (operatorToken.isIncrementOperator) { + _writeMarker(MarkerTag.PrefixExpression_readElement); _resolutionSink.writeElement(node.readElement); + _writeMarker(MarkerTag.PrefixExpression_readType); _resolutionSink.writeType(node.readType); + _writeMarker(MarkerTag.PrefixExpression_writeElement); _resolutionSink.writeElement(node.writeElement); + _writeMarker(MarkerTag.PrefixExpression_writeType); _resolutionSink.writeType(node.writeType); } } + _writeMarker(MarkerTag.PrefixExpression_expression); _storeExpression(node); + _writeMarker(MarkerTag.PrefixExpression_end); } @override @@ -1266,10 +1493,14 @@ class AstBinaryWriter extends ThrowingAstVisitor { hasPeriod2: node.operator?.type == TokenType.PERIOD_PERIOD, ), ); + _writeMarker(MarkerTag.PropertyAccess_target); _writeOptionalNode(node.target); + _writeMarker(MarkerTag.PropertyAccess_propertyName); _writeNode(node.propertyName); // TODO(scheglov) Get from the property? + _writeMarker(MarkerTag.PropertyAccess_expression); _storeExpression(node); + _writeMarker(MarkerTag.PropertyAccess_end); } @override @@ -1283,12 +1514,15 @@ class AstBinaryWriter extends ThrowingAstVisitor { ), ); + _writeMarker(MarkerTag.RedirectingConstructorInvocation_constructorName); _writeOptionalNode(node.constructorName); + _writeMarker(MarkerTag.RedirectingConstructorInvocation_argumentList); _writeNode(node.argumentList); if (_shouldWriteResolution) { + _writeMarker(MarkerTag.RedirectingConstructorInvocation_staticElement); _resolutionSink.writeElement(node.staticElement); } - _storeConstructorInitializer(node); + _writeMarker(MarkerTag.RedirectingConstructorInvocation_end); } @override @@ -1304,13 +1538,18 @@ class AstBinaryWriter extends ThrowingAstVisitor { if (_shouldWriteResolution) { var isMapBit = node.isMap ? (1 << 0) : 0; var isSetBit = node.isSet ? (1 << 1) : 0; + _writeMarker(MarkerTag.SetOrMapLiteral_flags); _resolutionSink.writeByte(isMapBit | isSetBit); } + _writeMarker(MarkerTag.SetOrMapLiteral_typeArguments); _writeOptionalNode(node.typeArguments); + _writeMarker(MarkerTag.SetOrMapLiteral_elements); _writeNodeList(node.elements); + _writeMarker(MarkerTag.SetOrMapLiteral_expression); _storeExpression(node); + _writeMarker(MarkerTag.SetOrMapLiteral_end); } @override @@ -1324,13 +1563,17 @@ class AstBinaryWriter extends ThrowingAstVisitor { void visitSimpleFormalParameter(SimpleFormalParameter node) { _writeByte(Tag.SimpleFormalParameter); + _writeMarker(MarkerTag.SimpleFormalParameter_type); _writeOptionalNode(node.type); + _writeMarker(MarkerTag.SimpleFormalParameter_normalFormalParameter); _storeNormalFormalParameter(node, node.keyword); if (_shouldWriteResolution) { var element = node.declaredElement as ParameterElementImpl; + _writeMarker(MarkerTag.SimpleFormalParameter_flags); _resolutionSink.writeByte(element.inheritsCovariant ? 1 : 0); } + _writeMarker(MarkerTag.SimpleFormalParameter_end); } @override @@ -1339,10 +1582,13 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeStringReference(node.name); _writeInformativeUint30(node.offset); if (_shouldWriteResolution) { + _writeMarker(MarkerTag.SimpleIdentifier_staticElement); _resolutionSink.writeElement(node.staticElement); // TODO(scheglov) It is inefficient to write many null types. - _resolutionSink.writeType(node.staticType); } + _writeMarker(MarkerTag.SimpleIdentifier_expression); + _storeExpression(node); + _writeMarker(MarkerTag.SimpleIdentifier_end); } @override @@ -1361,31 +1607,40 @@ class AstBinaryWriter extends ThrowingAstVisitor { node.spreadOperator.type == TokenType.PERIOD_PERIOD_PERIOD_QUESTION, ), ); + _writeMarker(MarkerTag.SpreadElement_expression); _writeNode(node.expression); + _writeMarker(MarkerTag.SpreadElement_end); } @override void visitStringInterpolation(StringInterpolation node) { _writeByte(Tag.StringInterpolation); + _writeMarker(MarkerTag.StringInterpolation_elements); _writeNodeList(node.elements); + _writeMarker(MarkerTag.StringInterpolation_end); } @override void visitSuperConstructorInvocation(SuperConstructorInvocation node) { _writeByte(Tag.SuperConstructorInvocation); + _writeMarker(MarkerTag.SuperConstructorInvocation_constructorName); _writeOptionalNode(node.constructorName); + _writeMarker(MarkerTag.SuperConstructorInvocation_argumentList); _writeNode(node.argumentList); if (_shouldWriteResolution) { + _writeMarker(MarkerTag.SuperConstructorInvocation_staticElement); _resolutionSink.writeElement(node.staticElement); } - _storeConstructorInitializer(node); + _writeMarker(MarkerTag.SuperConstructorInvocation_end); } @override void visitSuperExpression(SuperExpression node) { _writeByte(Tag.SuperExpression); + _writeMarker(MarkerTag.SuperExpression_expression); _storeExpression(node); + _writeMarker(MarkerTag.SuperExpression_end); } @override @@ -1403,14 +1658,19 @@ class AstBinaryWriter extends ThrowingAstVisitor { @override void visitThisExpression(ThisExpression node) { _writeByte(Tag.ThisExpression); + _writeMarker(MarkerTag.ThisExpression_expression); _storeExpression(node); + _writeMarker(MarkerTag.ThisExpression_end); } @override void visitThrowExpression(ThrowExpression node) { _writeByte(Tag.ThrowExpression); + _writeMarker(MarkerTag.ThrowExpression_expression); _writeNode(node.expression); + _writeMarker(MarkerTag.ThrowExpression_expression2); _storeExpression(node); + _writeMarker(MarkerTag.ThrowExpression_end); } @override @@ -1439,12 +1699,15 @@ class AstBinaryWriter extends ThrowingAstVisitor { _shouldStoreVariableInitializers = node.variables.isConst; try { + _writeMarker(MarkerTag.TopLevelVariableDeclaration_variables); _writeNode(node.variables); } finally { _shouldStoreVariableInitializers = false; } + _writeMarker(MarkerTag.TopLevelVariableDeclaration_compilationUnitMember); _storeCompilationUnitMember(node); + _writeMarker(MarkerTag.TopLevelVariableDeclaration_end); _writeUInt30(resolutionIndex); } @@ -1452,7 +1715,9 @@ class AstBinaryWriter extends ThrowingAstVisitor { @override void visitTypeArgumentList(TypeArgumentList node) { _writeByte(Tag.TypeArgumentList); + _writeMarker(MarkerTag.TypeArgumentList_arguments); _writeNodeList(node.arguments); + _writeMarker(MarkerTag.TypeArgumentList_end); } @override @@ -1466,12 +1731,16 @@ class AstBinaryWriter extends ThrowingAstVisitor { ), ); + _writeMarker(MarkerTag.TypeName_name); _writeNode(node.name); + _writeMarker(MarkerTag.TypeName_typeArguments); _writeOptionalNode(node.typeArguments); if (_shouldWriteResolution) { + _writeMarker(MarkerTag.TypeName_type); _resolutionSink.writeType(node.type); } + _writeMarker(MarkerTag.TypeName_end); } @override @@ -1480,22 +1749,29 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeInformativeUint30(node.offset); _writeInformativeUint30(node.length); _writeDeclarationName(node.name); + _writeMarker(MarkerTag.TypeParameter_bound); _writeOptionalNode(node.bound); + _writeMarker(MarkerTag.TypeParameter_declaration); _storeDeclaration(node); if (_shouldWriteResolution) { var element = node.declaredElement as TypeParameterElementImpl; + _writeMarker(MarkerTag.TypeParameter_variance); _resolutionSink.writeByte( _encodeVariance(element), ); + _writeMarker(MarkerTag.TypeParameter_defaultType); _resolutionSink.writeType(element.defaultType); } + _writeMarker(MarkerTag.TypeParameter_end); } @override void visitTypeParameterList(TypeParameterList node) { _writeByte(Tag.TypeParameterList); + _writeMarker(MarkerTag.TypeParameterList_typeParameters); _writeNodeList(node.typeParameters); + _writeMarker(MarkerTag.TypeParameterList_end); } @override @@ -1511,9 +1787,12 @@ class AstBinaryWriter extends ThrowingAstVisitor { if (_shouldWriteResolution) { // TODO(scheglov) Enforce not null, remove `?` in `?.type` below. var element = node.declaredElement as VariableElementImpl; + _writeMarker(MarkerTag.VariableDeclaration_type); _writeActualType(element?.type); + _writeMarker(MarkerTag.VariableDeclaration_inferenceError); _writeTopLevelInferenceError(element); if (element is FieldElementImpl) { + _writeMarker(MarkerTag.VariableDeclaration_inheritsCovariant); _resolutionSink.writeByte(element.inheritsCovariant ? 1 : 0); } } @@ -1525,7 +1804,9 @@ class AstBinaryWriter extends ThrowingAstVisitor { initializerToWrite = initializer; } } + _writeMarker(MarkerTag.VariableDeclaration_initializer); _writeOptionalNode(initializerToWrite); + _writeMarker(MarkerTag.VariableDeclaration_end); } @override @@ -1539,15 +1820,21 @@ class AstBinaryWriter extends ThrowingAstVisitor { isVar: node.keyword?.keyword == Keyword.VAR, ), ); + _writeMarker(MarkerTag.VariableDeclarationList_type); _writeOptionalNode(node.type); + _writeMarker(MarkerTag.VariableDeclarationList_variables); _writeNodeList(node.variables); + _writeMarker(MarkerTag.VariableDeclarationList_annotatedNode); _storeAnnotatedNode(node); + _writeMarker(MarkerTag.VariableDeclarationList_end); } @override void visitWithClause(WithClause node) { _writeByte(Tag.WithClause); + _writeMarker(MarkerTag.WithClause_mixinTypes); _writeNodeList(node.mixinTypes); + _writeMarker(MarkerTag.WithClause_end); } void _pushScopeTypeParameters(TypeParameterList node) { @@ -1567,10 +1854,13 @@ class AstBinaryWriter extends ThrowingAstVisitor { } void _storeAnnotatedNode(AnnotatedNode node) { + _writeMarker(MarkerTag.AnnotatedNode_metadata); _writeNodeList(node.metadata); + _writeMarker(MarkerTag.AnnotatedNode_end); } void _storeClassMember(ClassMember node) { + _writeMarker(MarkerTag.ClassMember_declaration); _storeDeclaration(node); } @@ -1578,8 +1868,6 @@ class AstBinaryWriter extends ThrowingAstVisitor { _storeDeclaration(node); } - void _storeConstructorInitializer(ConstructorInitializer node) {} - void _storeDeclaration(Declaration node) { _storeAnnotatedNode(node); } @@ -1591,19 +1879,24 @@ class AstBinaryWriter extends ThrowingAstVisitor { void _storeExpression(Expression node) { if (_shouldWriteResolution) { + _writeMarker(MarkerTag.Expression_staticType); _resolutionSink.writeType(node.staticType); } } void _storeForEachParts(ForEachParts node) { + _writeMarker(MarkerTag.ForEachParts_iterable); _writeNode(node.iterable); + _writeMarker(MarkerTag.ForEachParts_forLoopParts); _storeForLoopParts(node); + _writeMarker(MarkerTag.ForEachParts_end); } void _storeForLoopParts(ForLoopParts node) {} void _storeFormalParameter(FormalParameter node) { if (_shouldWriteResolution) { + _writeMarker(MarkerTag.FormalParameter_type); _writeActualType(node.declaredElement.type); } } @@ -1614,19 +1907,28 @@ class AstBinaryWriter extends ThrowingAstVisitor { hasAwait: node.awaitKeyword != null, ), ); + _writeMarker(MarkerTag.ForMixin_forLoopParts); _writeNode(node.forLoopParts); } void _storeForParts(ForParts node) { + _writeMarker(MarkerTag.ForParts_condition); _writeOptionalNode(node.condition); + _writeMarker(MarkerTag.ForParts_updaters); _writeNodeList(node.updaters); + _writeMarker(MarkerTag.ForParts_forLoopParts); _storeForLoopParts(node); + _writeMarker(MarkerTag.ForParts_end); } void _storeInvocationExpression(InvocationExpression node) { + _writeMarker(MarkerTag.InvocationExpression_typeArguments); _writeOptionalNode(node.typeArguments); + _writeMarker(MarkerTag.InvocationExpression_argumentList); _writeNode(node.argumentList); + _writeMarker(MarkerTag.InvocationExpression_expression); _storeExpression(node); + _writeMarker(MarkerTag.InvocationExpression_end); // TODO(scheglov) typeArgumentTypes and staticInvokeType? } @@ -1636,9 +1938,13 @@ class AstBinaryWriter extends ThrowingAstVisitor { } void _storeNamespaceDirective(NamespaceDirective node) { + _writeMarker(MarkerTag.NamespaceDirective_combinators); _writeNodeList(node.combinators); + _writeMarker(MarkerTag.NamespaceDirective_configurations); _writeNodeList(node.configurations); + _writeMarker(MarkerTag.NamespaceDirective_uriBasedDirective); _storeUriBasedDirective(node); + _writeMarker(MarkerTag.NamespaceDirective_end); } void _storeNormalFormalParameter( @@ -1662,11 +1968,14 @@ class AstBinaryWriter extends ThrowingAstVisitor { _writeInformativeUint30(node.offset); _writeInformativeUint30(node.length); + _writeMarker(MarkerTag.NormalFormalParameter_metadata); _writeNodeList(node.metadata); if (node.identifier != null) { _writeDeclarationName(node.identifier); } + _writeMarker(MarkerTag.NormalFormalParameter_formalParameter); _storeFormalParameter(node); + _writeMarker(MarkerTag.NormalFormalParameter_end); } void _storeTypeAlias(TypeAlias node) { @@ -1674,8 +1983,11 @@ class AstBinaryWriter extends ThrowingAstVisitor { } void _storeUriBasedDirective(UriBasedDirective node) { + _writeMarker(MarkerTag.UriBasedDirective_uri); _writeNode(node.uri); + _writeMarker(MarkerTag.UriBasedDirective_directive); _storeDirective(node); + _writeMarker(MarkerTag.UriBasedDirective_end); } void _writeActualReturnType(DartType type) { @@ -1784,6 +2096,14 @@ class AstBinaryWriter extends ThrowingAstVisitor { } } + void _writeMarker(MarkerTag tag) { + if (enableDebugResolutionMarkers) { + if (_shouldWriteResolution) { + _resolutionSink.writeUInt30(tag.index); + } + } + } + void _writeNode(AstNode node) { node.accept(this); } diff --git a/pkg/analyzer/lib/src/summary2/bundle_writer.dart b/pkg/analyzer/lib/src/summary2/bundle_writer.dart index a21430d26725c..09253380a4003 100644 --- a/pkg/analyzer/lib/src/summary2/bundle_writer.dart +++ b/pkg/analyzer/lib/src/summary2/bundle_writer.dart @@ -466,6 +466,10 @@ class ResolutionSink { } } + void writeUInt30(int value) { + _sink.writeUInt30(value); + } + int _indexOfElement(Element element) { if (element == null) return 0; if (element is MultiplyDefinedElement) return 0;