// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'dart:math';

import 'package:analyzer/dart/ast/ast.dart';
import 'package:analyzer/dart/ast/visitor.dart';
import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/dart/element/type.dart';
import 'package:analyzer/src/dart/ast/ast.dart';
import 'package:analyzer/src/dart/ast/ast_factory.dart';
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';
import 'package:analyzer/src/task/inference_error.dart';
import 'package:collection/collection.dart';

class ApplyResolutionVisitor extends ThrowingAstVisitor<void> {
  final LinkedUnitContext _unitContext;
  final LinkedResolutionReader _resolution;

  /// The stack of [TypeParameterElement]s and [ParameterElement] that are
  /// available in the scope of [_nextElement] and [_nextType].
  ///
  /// This stack is shared with [_resolution].
  final List<Element> _localElements;

  final List<ElementImpl> _enclosingElements = [];

  ApplyResolutionVisitor(
    this._unitContext,
    this._localElements,
    this._resolution,
  ) {
    _enclosingElements.add(_unitContext.element);
  }

  /// TODO(scheglov) make private
  void addParentTypeParameters(AstNode node) {
    var enclosing = node.parent;
    if (enclosing is ClassOrMixinDeclaration) {
      var typeParameterList = enclosing.typeParameters;
      if (typeParameterList == null) return;

      for (var typeParameter in typeParameterList.typeParameters) {
        var element = typeParameter.declaredElement!;
        _localElements.add(element);
      }
    } else if (enclosing is ExtensionDeclaration) {
      var typeParameterList = enclosing.typeParameters;
      if (typeParameterList == null) return;

      for (var typeParameter in typeParameterList.typeParameters) {
        var element = typeParameter.declaredElement!;
        _localElements.add(element);
      }
    } else if (enclosing is VariableDeclarationList) {
      var enclosing2 = enclosing.parent;
      if (enclosing2 is FieldDeclaration) {
        return addParentTypeParameters(enclosing2);
      } else if (enclosing2 is TopLevelVariableDeclaration) {
        return;
      } else {
        throw UnimplementedError('${enclosing2.runtimeType}');
      }
    } else {
      throw UnimplementedError('${enclosing.runtimeType}');
    }
  }

  @override
  void visitAdjacentStrings(AdjacentStrings node) {
    node.strings.accept(this);
    // TODO(scheglov) type?
  }

  @override
  void visitAnnotation(covariant AnnotationImpl 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(covariant AsExpressionImpl 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() as MethodElement?;
    _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 visitAwaitExpression(covariant AwaitExpressionImpl node) {
    _expectMarker(MarkerTag.AwaitExpression_expression);
    node.expression.accept(this);
    _expectMarker(MarkerTag.AwaitExpression_expression2);
    _expression(node);
    _expectMarker(MarkerTag.AwaitExpression_end);
  }

  @override
  void visitBinaryExpression(covariant BinaryExpressionImpl node) {
    _expectMarker(MarkerTag.BinaryExpression_leftOperand);
    node.leftOperand.accept(this);
    _expectMarker(MarkerTag.BinaryExpression_rightOperand);
    node.rightOperand.accept(this);

    _expectMarker(MarkerTag.BinaryExpression_staticElement);
    node.staticElement = _nextElement() as MethodElement?;

    _expectMarker(MarkerTag.BinaryExpression_expression);
    _expression(node);
    _expectMarker(MarkerTag.BinaryExpression_end);
  }

  @override
  void visitBooleanLiteral(covariant BooleanLiteralImpl node) {
    _expression(node);
  }

  @override
  void visitCascadeExpression(covariant CascadeExpressionImpl 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;
  }

  @override
  visitClassDeclaration(ClassDeclaration node) {
    _assertNoLocalElements();

    var element = node.declaredElement as ClassElementImpl;
    element.isSimplyBounded = _resolution.readByte() != 0;
    _enclosingElements.add(element);

    try {
      _expectMarker(MarkerTag.ClassDeclaration_typeParameters);
      node.typeParameters?.accept(this);
      _expectMarker(MarkerTag.ClassDeclaration_extendsClause);
      node.extendsClause?.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);
      throw CaughtExceptionWithFiles(e, stackTrace, {
        'state': '''
element: ${element.reference}
header: $headerStr
resolution.bytes.length: ${_resolution.bytes.length}
resolution.byteOffset: ${_resolution.byteOffset}
''',
      });
    }

    _enclosingElements.removeLast();
  }

  @override
  void visitClassTypeAlias(ClassTypeAlias node) {
    _assertNoLocalElements();
    var element = node.declaredElement as ClassElementImpl;
    _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);
    _expectMarker(MarkerTag.ClassTypeAlias_typeAlias);
    _typeAlias(node);
    _expectMarker(MarkerTag.ClassTypeAlias_end);

    _enclosingElements.removeLast();
  }

  @override
  void visitConditionalExpression(covariant ConditionalExpressionImpl 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);
    _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
  void visitConstructorDeclaration(ConstructorDeclaration node) {
    _assertNoLocalElements();
    _pushEnclosingClassTypeParameters(node);

    var element = node.declaredElement as ConstructorElementImpl;
    _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);
    _expectMarker(MarkerTag.ConstructorDeclaration_classMember);
    _classMember(node);
    _expectMarker(MarkerTag.ConstructorDeclaration_end);

    _enclosingElements.removeLast();
    _enclosingElements.removeLast();
  }

  @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
  void visitConstructorName(covariant ConstructorNameImpl node) {
    // Rewrite:
    //   ConstructorName
    //     type: TypeName
    //       name: PrefixedIdentifier
    //     name: null
    // into:
    //    ConstructorName
    //      type: TypeName
    //        name: SimpleIdentifier
    //      name: SimpleIdentifier
    var hasName = _resolution.readByte() != 0;
    if (hasName && node.name == null) {
      var typeName = node.type.name as PrefixedIdentifier;
      NodeReplacer.replace(
        node.type,
        astFactory.typeName(typeName.prefix, null),
      );
      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() as ConstructorElement?;
    _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
  visitDefaultFormalParameter(DefaultFormalParameter node) {
    var nodeImpl = node as DefaultFormalParameterImpl;

    var enclosing = _enclosingElements.last;
    var name = node.identifier?.name ?? '';
    var enclosingReference = enclosing.reference;
    var reference = node.isNamed && enclosingReference != null
        ? enclosingReference.getChild('@parameter').getChild(name)
        : null;
    ParameterElementImpl element;
    if (node.parameter is FieldFormalParameter) {
      element = DefaultFieldFormalParameterElementImpl.forLinkedNode(
          enclosing, reference, node);
    } else {
      element =
          DefaultParameterElementImpl.forLinkedNode(enclosing, reference, node);
    }

    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
  void visitDottedName(DottedName node) {
    node.components.accept(this);
  }

  @override
  void visitDoubleLiteral(DoubleLiteral node) {
    // TODO(scheglov) type?
  }

  @override
  void visitEnumConstantDeclaration(EnumConstantDeclaration node) {
    _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);
    _expectMarker(MarkerTag.EnumDeclaration_namedCompilationUnitMember);
    _namedCompilationUnitMember(node);
    _expectMarker(MarkerTag.EnumDeclaration_end);
  }

  @override
  void visitExportDirective(ExportDirective node) {
    var elementImpl = node.element as ExportElementImpl;
    _expectMarker(MarkerTag.ExportDirective_namespaceDirective);
    _namespaceDirective(node);
    _expectMarker(MarkerTag.ExportDirective_exportedLibrary);
    elementImpl.exportedLibrary = _nextElement() as LibraryElement?;
    _expectMarker(MarkerTag.ExportDirective_end);
  }

  @override
  void visitExpressionFunctionBody(ExpressionFunctionBody node) {
    node.expression.accept(this);
  }

  @override
  visitExtendsClause(ExtendsClause node) {
    _expectMarker(MarkerTag.ExtendsClause_superclass);
    node.superclass.accept(this);
    _expectMarker(MarkerTag.ExtendsClause_end);
  }

  @override
  void visitExtensionDeclaration(ExtensionDeclaration node) {
    _assertNoLocalElements();

    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);
    _expectMarker(MarkerTag.ExtensionDeclaration_compilationUnitMember);
    _compilationUnitMember(node);
    _expectMarker(MarkerTag.ExtensionDeclaration_end);

    _enclosingElements.removeLast();
  }

  @override
  void visitExtensionOverride(
    ExtensionOverride node, {
    bool readRewrite = true,
  }) {
    // Read possible rewrite of `MethodInvocation`.
    // If we are here, we don't need it.
    if (readRewrite) {
      _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?
  }

  @override
  void visitFieldDeclaration(FieldDeclaration node) {
    _assertNoLocalElements();
    _pushEnclosingClassTypeParameters(node);

    _expectMarker(MarkerTag.FieldDeclaration_fields);
    node.fields.accept(this);
    _expectMarker(MarkerTag.FieldDeclaration_classMember);
    _classMember(node);
    _expectMarker(MarkerTag.FieldDeclaration_end);
  }

  @override
  void visitFieldFormalParameter(covariant FieldFormalParameterImpl node) {
    if (node.declaredElement == null) {
      assert(node.parent is! DefaultFormalParameter);
      var enclosing = _enclosingElements.last;
      var element =
          FieldFormalParameterElementImpl.forLinkedNode(enclosing, null, node);
      _normalFormalParameterNotDefault(node, element);
    }

    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);
    _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_forLoopParts);
    node.forLoopParts.accept(this);
    _expectMarker(MarkerTag.ForElement_body);
    node.body.accept(this);
    _expectMarker(MarkerTag.ForElement_end);
  }

  @override
  visitFormalParameterList(FormalParameterList node) {
    _expectMarker(MarkerTag.FormalParameterList_parameters);
    node.parameters.accept(this);
    _expectMarker(MarkerTag.FormalParameterList_end);
  }

  @override
  void visitForPartsWithDeclarations(ForPartsWithDeclarations node) {
    for (var variable in node.variables.variables) {
      variable as VariableDeclarationImpl;
      var nameNode = variable.name;
      nameNode.staticElement = LocalVariableElementImpl(
        nameNode.name,
        nameNode.offset,
      );
    }
    _expectMarker(MarkerTag.ForPartsWithDeclarations_variables);
    node.variables.accept(this);
    _expectMarker(MarkerTag.ForPartsWithDeclarations_forParts);
    _forParts(node);
    _expectMarker(MarkerTag.ForPartsWithDeclarations_end);
  }

  @override
  void visitForPartsWithExpression(ForPartsWithExpression node) {
    _expectMarker(MarkerTag.ForPartsWithExpression_initialization);
    node.initialization?.accept(this);
    _expectMarker(MarkerTag.ForPartsWithExpression_forParts);
    _forParts(node);
    _expectMarker(MarkerTag.ForPartsWithExpression_end);
  }

  @override
  void visitFunctionDeclaration(FunctionDeclaration node) {
    _assertNoLocalElements();

    var element = node.declaredElement as ExecutableElementImpl;
    _enclosingElements.add(element);

    _expectMarker(MarkerTag.FunctionDeclaration_functionExpression);
    node.functionExpression.accept(this);
    _expectMarker(MarkerTag.FunctionDeclaration_returnType);
    node.returnType?.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
  void visitFunctionExpressionInvocation(
    covariant FunctionExpressionInvocationImpl node, {
    bool readRewrite = true,
  }) {
    // Read possible rewrite of `MethodInvocation`.
    // If we are here, we don't need it.
    if (readRewrite) {
      _resolution.readByte();
    }

    _expectMarker(MarkerTag.FunctionExpressionInvocation_function);
    node.function.accept(this);
    _expectMarker(MarkerTag.FunctionExpressionInvocation_invocationExpression);
    _invocationExpression(node);
    _expectMarker(MarkerTag.FunctionExpressionInvocation_end);
  }

  @override
  void visitFunctionTypeAlias(FunctionTypeAlias node) {
    _assertNoLocalElements();

    var element = node.declaredElement as TypeAliasElementImpl;
    _enclosingElements.add(element);

    _expectMarker(MarkerTag.FunctionTypeAlias_typeParameters);
    node.typeParameters?.accept(this);

    var function = element.aliasedElement as GenericFunctionTypeElementImpl;
    _enclosingElements.add(function);

    _expectMarker(MarkerTag.FunctionTypeAlias_returnType);
    node.returnType?.accept(this);
    _expectMarker(MarkerTag.FunctionTypeAlias_parameters);
    node.parameters.accept(this);
    _enclosingElements.removeLast();

    _expectMarker(MarkerTag.FunctionTypeAlias_typeAlias);
    _typeAlias(node);

    _expectMarker(MarkerTag.FunctionTypeAlias_returnTypeType);
    function.returnType = _nextType()!;
    _expectMarker(MarkerTag.FunctionTypeAlias_flags);
    element.isSimplyBounded = _resolution.readByte() != 0;
    element.hasSelfReference = _resolution.readByte() != 0;
    _expectMarker(MarkerTag.FunctionTypeAlias_end);

    _enclosingElements.removeLast();
  }

  @override
  void visitFunctionTypedFormalParameter(
      covariant FunctionTypedFormalParameterImpl node) {
    if (node.declaredElement == null) {
      assert(node.parent is! DefaultFormalParameter);
      var enclosing = _enclosingElements.last;
      var element =
          ParameterElementImpl.forLinkedNodeFactory(enclosing, null, node);
      _normalFormalParameterNotDefault(node, element);
    }

    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);
    _expectMarker(MarkerTag.FunctionTypedFormalParameter_end);

    _localElements.length = localElementsLength;
  }

  @override
  void visitGenericFunctionType(GenericFunctionType node) {
    var nodeImpl = node as GenericFunctionTypeImpl;
    var localElementsLength = _localElements.length;

    var element = nodeImpl.declaredElement as GenericFunctionTypeElementImpl?;
    element ??= GenericFunctionTypeElementImpl.forLinkedNode(
        _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();
  }

  @override
  void visitGenericTypeAlias(GenericTypeAlias node) {
    _assertNoLocalElements();

    var element = node.declaredElement as TypeAliasElementImpl;
    _enclosingElements.add(element);

    _expectMarker(MarkerTag.GenericTypeAlias_typeParameters);
    node.typeParameters?.accept(this);
    _expectMarker(MarkerTag.GenericTypeAlias_type);
    node.type.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();
  }

  @override
  void visitHideCombinator(HideCombinator node) {
    node.hiddenNames.accept(this);
  }

  @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() as LibraryElement?;

    _expectMarker(MarkerTag.ImportDirective_end);
  }

  @override
  void visitIndexExpression(covariant IndexExpressionImpl node) {
    _expectMarker(MarkerTag.IndexExpression_target);
    node.target?.accept(this);
    _expectMarker(MarkerTag.IndexExpression_index);
    node.index.accept(this);
    _expectMarker(MarkerTag.IndexExpression_staticElement);
    node.staticElement = _nextElement() as MethodElement?;
    _expectMarker(MarkerTag.IndexExpression_expression);
    _expression(node);
    _expectMarker(MarkerTag.IndexExpression_end);
  }

  @override
  void visitInstanceCreationExpression(
    covariant InstanceCreationExpressionImpl node, {
    bool readRewrite = true,
  }) {
    // Read possible rewrite of `MethodInvocation`.
    // If we are here, we don't need it.
    if (readRewrite) {
      _resolution.readByte();
    }

    _expectMarker(MarkerTag.InstanceCreationExpression_constructorName);
    node.constructorName.accept(this);
    _expectMarker(MarkerTag.InstanceCreationExpression_argumentList);
    node.argumentList.accept(this);
    _expectMarker(MarkerTag.InstanceCreationExpression_expression);
    _expression(node);
    _expectMarker(MarkerTag.InstanceCreationExpression_end);
    _resolveNamedExpressions(
      node.constructorName.staticElement,
      node.argumentList,
    );
  }

  @override
  void visitIntegerLiteral(covariant IntegerLiteralImpl node) {
    _expression(node);
  }

  @override
  void visitInterpolationExpression(InterpolationExpression node) {
    node.expression.accept(this);
  }

  @override
  void visitInterpolationString(InterpolationString node) {
    // TODO(scheglov) type?
  }

  @override
  void visitIsExpression(covariant IsExpressionImpl 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
  void visitLibraryDirective(LibraryDirective node) {
    node.name.accept(this);
    _directive(node);
  }

  @override
  void visitLibraryIdentifier(LibraryIdentifier node) {
    node.components.accept(this);
  }

  @override
  void visitListLiteral(covariant ListLiteralImpl node) {
    _expectMarker(MarkerTag.ListLiteral_typeArguments);
    node.typeArguments?.accept(this);
    _expectMarker(MarkerTag.ListLiteral_elements);
    node.elements.accept(this);
    _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);
  }

  @override
  visitMethodDeclaration(MethodDeclaration node) {
    _assertNoLocalElements();
    _pushEnclosingClassTypeParameters(node);

    var element = node.declaredElement as ExecutableElementImpl;
    _enclosingElements.add(element.enclosingElement as ElementImpl);
    _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);
      _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);
      throw CaughtExceptionWithFiles(e, stackTrace, {
        'state': '''
element: ${element.reference}
header: $headerStr
resolution.bytes.length: ${_resolution.bytes.length}
resolution.byteOffset: ${_resolution.byteOffset}
''',
      });
    }

    _enclosingElements.removeLast();
    _enclosingElements.removeLast();
  }

  @override
  void visitMethodInvocation(covariant MethodInvocationImpl node) {
    var rewriteTag = _resolution.readByte();
    if (rewriteTag == MethodInvocationRewriteTag.none) {
      // No rewrite necessary.
    } else if (rewriteTag == MethodInvocationRewriteTag.extensionOverride) {
      Identifier identifier;
      if (node.target == null) {
        identifier = node.methodName;
      } else {
        identifier = astFactory.prefixedIdentifier(
          node.target as SimpleIdentifier,
          node.operator!,
          node.methodName,
        );
      }
      var replacement = astFactory.extensionOverride(
        extensionName: identifier,
        typeArguments: node.typeArguments,
        argumentList: node.argumentList,
      );
      NodeReplacer.replace(node, replacement);
      visitExtensionOverride(replacement, readRewrite: false);
      return;
    } else if (rewriteTag ==
        MethodInvocationRewriteTag.functionExpressionInvocation) {
      var target = node.target;
      Expression expression;
      if (target == null) {
        expression = node.methodName;
      } else {
        expression = astFactory.propertyAccess(
          target,
          node.operator!,
          node.methodName,
        );
      }
      var replacement = astFactory.functionExpressionInvocation(
        expression,
        node.typeArguments,
        node.argumentList,
      );
      NodeReplacer.replace(node, replacement);
      visitFunctionExpressionInvocation(replacement, readRewrite: false);
      return;
    } else if (rewriteTag ==
        MethodInvocationRewriteTag.instanceCreationExpression_withName) {
      var replacement = astFactory.instanceCreationExpression(
        null,
        astFactory.constructorName(
          astFactory.typeName(node.target as Identifier, null),
          node.operator,
          node.methodName,
        ),
        node.argumentList,
      );
      NodeReplacer.replace(node, replacement);
      visitInstanceCreationExpression(replacement, readRewrite: false);
      return;
    } else if (rewriteTag ==
        MethodInvocationRewriteTag.instanceCreationExpression_withoutName) {
      var typeNameName = node.target == null
          ? node.methodName
          : astFactory.prefixedIdentifier(
              node.target as SimpleIdentifier,
              node.operator!,
              node.methodName,
            );
      var replacement = astFactory.instanceCreationExpression(
        null,
        astFactory.constructorName(
          astFactory.typeName(typeNameName, node.typeArguments),
          null,
          null,
        ),
        node.argumentList,
      );
      NodeReplacer.replace(node, replacement);
      visitInstanceCreationExpression(replacement, readRewrite: false);
      return;
    } else {
      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
  void visitMixinDeclaration(MixinDeclaration node) {
    _assertNoLocalElements();
    var element = node.declaredElement as MixinElementImpl;
    element.isSimplyBounded = _resolution.readByte() != 0;
    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);
    _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
  void visitNullLiteral(NullLiteral node) {
    // TODO(scheglov) type?
  }

  @override
  void visitOnClause(OnClause node) {
    _expectMarker(MarkerTag.OnClause_superclassConstraints);
    node.superclassConstraints.accept(this);
    _expectMarker(MarkerTag.OnClause_end);
  }

  @override
  void visitParenthesizedExpression(
      covariant ParenthesizedExpressionImpl node) {
    _expectMarker(MarkerTag.ParenthesizedExpression_expression);
    node.expression.accept(this);
    _expectMarker(MarkerTag.ParenthesizedExpression_expression2);
    _expression(node);
    _expectMarker(MarkerTag.ParenthesizedExpression_end);
  }

  @override
  void visitPartDirective(PartDirective node) {
    _uriBasedDirective(node);
  }

  @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() as MethodElement?;
    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(covariant PrefixedIdentifierImpl 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() as MethodElement?;
    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(covariant PropertyAccessImpl node) {
    _expectMarker(MarkerTag.PropertyAccess_target);
    node.target?.accept(this);
    _expectMarker(MarkerTag.PropertyAccess_propertyName);
    node.propertyName.accept(this);

    _expectMarker(MarkerTag.PropertyAccess_expression);
    _expression(node);
    _expectMarker(MarkerTag.PropertyAccess_end);
  }

  @override
  void visitRedirectingConstructorInvocation(
      covariant RedirectingConstructorInvocationImpl node) {
    _expectMarker(MarkerTag.RedirectingConstructorInvocation_constructorName);
    node.constructorName?.accept(this);
    _expectMarker(MarkerTag.RedirectingConstructorInvocation_argumentList);
    node.argumentList.accept(this);
    _expectMarker(MarkerTag.RedirectingConstructorInvocation_staticElement);
    node.staticElement = _nextElement() as ConstructorElement?;
    _resolveNamedExpressions(node.staticElement, node.argumentList);
    _expectMarker(MarkerTag.RedirectingConstructorInvocation_end);
  }

  @override
  void visitSetOrMapLiteral(covariant SetOrMapLiteralImpl node) {
    _expectMarker(MarkerTag.SetOrMapLiteral_flags);
    var mapOrSetBits = _resolution.readByte();
    if ((mapOrSetBits & 0x01) != 0) {
      node.becomeMap();
    } else if ((mapOrSetBits & 0x02) != 0) {
      node.becomeSet();
    }

    _expectMarker(MarkerTag.SetOrMapLiteral_typeArguments);
    node.typeArguments?.accept(this);
    _expectMarker(MarkerTag.SetOrMapLiteral_elements);
    node.elements.accept(this);
    _expectMarker(MarkerTag.SetOrMapLiteral_expression);
    _expression(node);
    _expectMarker(MarkerTag.SetOrMapLiteral_end);
  }

  @override
  void visitShowCombinator(ShowCombinator node) {
    node.shownNames.accept(this);
  }

  @override
  visitSimpleFormalParameter(covariant SimpleFormalParameterImpl node) {
    var element = node.declaredElement as ParameterElementImpl?;
    if (element == null) {
      assert(node.parent is! DefaultFormalParameter);
      var enclosing = _enclosingElements.last;
      element =
          ParameterElementImpl.forLinkedNodeFactory(enclosing, null, node);
      _normalFormalParameterNotDefault(node, element);
    }

    _expectMarker(MarkerTag.SimpleFormalParameter_type);
    node.type?.accept(this);
    _expectMarker(MarkerTag.SimpleFormalParameter_normalFormalParameter);
    _normalFormalParameter(node);

    _expectMarker(MarkerTag.SimpleFormalParameter_flags);
    element.inheritsCovariant = _resolution.readByte() != 0;
    _expectMarker(MarkerTag.SimpleFormalParameter_end);
  }

  @override
  visitSimpleIdentifier(covariant SimpleIdentifierImpl node) {
    _expectMarker(MarkerTag.SimpleIdentifier_staticElement);
    node.staticElement = _nextElement();
    _expectMarker(MarkerTag.SimpleIdentifier_expression);
    _expression(node);
    _expectMarker(MarkerTag.SimpleIdentifier_end);
  }

  @override
  void visitSimpleStringLiteral(SimpleStringLiteral node) {
    // TODO(scheglov) type?
  }

  @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(
      covariant SuperConstructorInvocationImpl node) {
    _expectMarker(MarkerTag.SuperConstructorInvocation_constructorName);
    node.constructorName?.accept(this);
    _expectMarker(MarkerTag.SuperConstructorInvocation_argumentList);
    node.argumentList.accept(this);
    _expectMarker(MarkerTag.SuperConstructorInvocation_staticElement);
    node.staticElement = _nextElement() as ConstructorElement?;
    _resolveNamedExpressions(node.staticElement, node.argumentList);
    _expectMarker(MarkerTag.SuperConstructorInvocation_end);
  }

  @override
  void visitSuperExpression(covariant SuperExpressionImpl node) {
    _expectMarker(MarkerTag.SuperExpression_expression);
    _expression(node);
    _expectMarker(MarkerTag.SuperExpression_end);
  }

  @override
  void visitSymbolLiteral(covariant SymbolLiteralImpl node) {
    _expression(node);
  }

  @override
  void visitThisExpression(covariant ThisExpressionImpl node) {
    _expectMarker(MarkerTag.ThisExpression_expression);
    _expression(node);
    _expectMarker(MarkerTag.ThisExpression_end);
  }

  @override
  void visitThrowExpression(covariant ThrowExpressionImpl node) {
    _expectMarker(MarkerTag.ThrowExpression_expression);
    node.expression.accept(this);
    _expectMarker(MarkerTag.ThrowExpression_expression2);
    _expression(node);
    _expectMarker(MarkerTag.ThrowExpression_end);
  }

  @override
  void visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
    _expectMarker(MarkerTag.TopLevelVariableDeclaration_variables);
    node.variables.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(covariant TypeNameImpl 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
  visitTypeParameterList(TypeParameterList node) {
    for (var typeParameter in node.typeParameters) {
      typeParameter as TypeParameterImpl;
      var element = TypeParameterElementImpl.forLinkedNode(
        _enclosingElements.last,
        typeParameter,
      );
      _localElements.add(element);
    }

    _expectMarker(MarkerTag.TypeParameterList_typeParameters);
    for (var node in node.typeParameters) {
      var nodeImpl = node as TypeParameterImpl;
      var element = node.declaredElement as TypeParameterElementImpl;

      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;

      _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.
      // But the code below is bad and incomplete.
      // And why does this affect MethodMember(s)?
      {
        var parent = node.parent;
        if (parent is ClassDeclaration) {
          (parent.declaredElement as ElementImpl).encloseElement(element);
        } else if (parent is ClassTypeAlias) {
          (parent.declaredElement as ElementImpl).encloseElement(element);
        } else if (parent is ExtensionDeclaration) {
          (parent.declaredElement as ElementImpl).encloseElement(element);
        } else if (parent is FunctionExpression) {
          var parent2 = parent.parent;
          if (parent2 is FunctionDeclaration) {
            (parent2.declaredElement as ElementImpl).encloseElement(element);
          }
        } else if (parent is FunctionTypeAlias) {
          (parent.declaredElement as ElementImpl).encloseElement(element);
        } else if (parent is GenericTypeAlias) {
          (parent.declaredElement as ElementImpl).encloseElement(element);
        } else if (parent is MethodDeclaration) {
          (parent.declaredElement as ElementImpl).encloseElement(element);
        } else if (parent is MixinDeclaration) {
          (parent.declaredElement as ElementImpl).encloseElement(element);
        }
      }
    }
    _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);
    _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() {
    assert(_localElements.isEmpty);
    assert(_enclosingElements.length == 1 &&
        _enclosingElements.first is CompilationUnitElement);
  }

  /// Return annotations for the given [nodeList] in the [unit].
  List<ElementAnnotation> _buildAnnotations(
      CompilationUnitElementImpl unit, List<Annotation> nodeList) {
    var length = nodeList.length;
    if (length == 0) {
      return const <ElementAnnotation>[];
    }

    return List.generate(length, (index) {
      var ast = nodeList[index];
      return ElementAnnotationImpl(unit)
        ..annotationAst = ast
        ..element = ast.element;
    });
  }

  void _classMember(ClassMember node) {
    _expectMarker(MarkerTag.ClassMember_declaration);
    _declaration(node);
  }

  void _compilationUnitMember(CompilationUnitMember node) {
    _declaration(node);
  }

  void _declaration(Declaration node) {
    _annotatedNode(node);
  }

  void _directive(Directive node) {
    _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(ExpressionImpl node) {
    _expectMarker(MarkerTag.Expression_staticType);
    node.staticType = _nextType();
  }

  void _forEachParts(ForEachParts 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 _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(covariant InvocationExpressionImpl 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;
    nodeImpl.typeArgumentTypes = [];
  }

  void _namedCompilationUnitMember(NamedCompilationUnitMember node) {
    _compilationUnitMember(node);
  }

  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() {
    return _resolution.nextElement();
  }

  DartType? _nextType() {
    return _resolution.nextType();
  }

  void _normalFormalParameter(NormalFormalParameter node) {
    _expectMarker(MarkerTag.NormalFormalParameter_metadata);
    node.metadata.accept(this);
    _expectMarker(MarkerTag.NormalFormalParameter_formalParameter);
    _formalParameter(node);
    _expectMarker(MarkerTag.NormalFormalParameter_end);
  }

  void _normalFormalParameterNotDefault(
      NormalFormalParameter node, ParameterElementImpl element) {
    var nodeImpl = node as NormalFormalParameterImpl;
    var summaryData = nodeImpl.summaryData as SummaryDataForFormalParameter;
    element.setCodeRange(summaryData.codeOffset, summaryData.codeLength);
  }

  /// TODO(scheglov) also enclosing elements
  void _pushEnclosingClassTypeParameters(ClassMember node) {
    var parent = node.parent;
    if (parent is ClassOrMixinDeclaration) {
      var classElement = parent.declaredElement!;
      _localElements.addAll(classElement.typeParameters);
    } else {
      var extension = parent as ExtensionDeclaration;
      var classElement = extension.declaredElement!;
      _localElements.addAll(classElement.typeParameters);
    }
  }

  TopLevelInferenceError? _readTopLevelInferenceError() {
    var kindIndex = _resolution.readByte();
    var kind = TopLevelInferenceErrorKind.values[kindIndex];
    if (kind == TopLevelInferenceErrorKind.none) {
      return null;
    }
    return TopLevelInferenceError(
      kind: kind,
      arguments: _resolution.readStringList(),
    );
  }

  void _resolveNamedExpressions(
    Element? executable,
    ArgumentList argumentList,
  ) {
    for (var argument in argumentList.arguments) {
      if (argument is NamedExpressionImpl) {
        var nameNode = argument.name.label;
        if (executable is ExecutableElement) {
          var parameters = executable.parameters;
          var name = nameNode.name;
          nameNode.staticElement = parameters.firstWhereOrNull((e) {
            return e.name == name;
          });
        }
      }
    }
  }

  void _setTopLevelInferenceError(ElementImpl element) {
    if (element is MethodElementImpl) {
      element.typeInferenceError = _readTopLevelInferenceError();
    } else if (element is PropertyInducingElementImpl) {
      element.typeInferenceError = _readTopLevelInferenceError();
    }
  }

  void _typeAlias(TypeAlias node) {
    _namedCompilationUnitMember(node);
  }

  void _uriBasedDirective(UriBasedDirective 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
  static String _astCodeBeforeMarkerOrMaxLength(
      AstNode node, String marker, int maxLength) {
    var nodeStr = '$node';
    var indexOfBody = nodeStr.indexOf(marker);
    if (indexOfBody == -1) {
      indexOfBody = min(maxLength, nodeStr.length);
    }
    return nodeStr.substring(0, indexOfBody);
  }

  static Variance? _decodeVariance(int encoding) {
    if (encoding == 0) {
      return null;
    } else if (encoding == 1) {
      return Variance.unrelated;
    } else if (encoding == 2) {
      return Variance.covariant;
    } else if (encoding == 3) {
      return Variance.contravariant;
    } else if (encoding == 4) {
      return Variance.invariant;
    } else {
      throw UnimplementedError('encoding: $encoding');
    }
  }
}