anchor.diff:    }
   
     @override
  +  void endClassConstructor(Token getOrSet, Token beginToken, Token beginParam,
  +      Token beginInitializers, Token endToken) {
  +    assert(getOrSet == null ||
  +        optional('get', getOrSet) ||
  +        optional('set', getOrSet));
  +    debugEvent("ClassConstructor");
  +
  +    var bodyObject = pop();
  +    List<ConstructorInitializer> initializers = pop() ?? const [];
  +    Token separator = pop();
  +    FormalParameterList parameters = pop();
  +    TypeParameterList typeParameters = pop();
  +    var name = pop();
  +    TypeAnnotation returnType = pop();
  +    _Modifiers modifiers = pop();
  +    List<Annotation> metadata = pop();
  +    Comment comment = _findComment(metadata, beginToken);
  +
  +    assert(parameters != null || optional('get', getOrSet));
  +
  +    ConstructorName redirectedConstructor;
  +    FunctionBody body;
  +    if (bodyObject is FunctionBody) {
  +      body = bodyObject;
  +    } else if (bodyObject is _RedirectingFactoryBody) {
  +      separator = bodyObject.equalToken;
  +      redirectedConstructor = bodyObject.constructorName;
  +      body = ast.emptyFunctionBody(endToken);
  +    } else {
  +      unhandled("${bodyObject.runtimeType}", "bodyObject",
  +          beginToken.charOffset, uri);
  +    }
  +
  +    SimpleIdentifier prefixOrName;
  +    Token period;
  +    SimpleIdentifier nameOrNull;
  +    if (name is SimpleIdentifier) {
  +      prefixOrName = name;
  +    } else if (name is PrefixedIdentifier) {
  +      prefixOrName = name.prefix;
  +      period = name.period;
  +      nameOrNull = name.identifier;
  +    } else {
  +      throw new UnimplementedError(
  +          'name is an instance of ${name.runtimeType} in endClassConstructor');
  +    }
  +
  +    if (typeParameters != null) {
  +      // Outline builder also reports this error message.
  +      handleRecoverableError(messageConstructorWithTypeParameters,
  +          typeParameters.beginToken, typeParameters.endToken);
  +    }
  +    if (modifiers?.constKeyword != null &&
  +        body != null &&
  +        (body.length > 1 || body.beginToken?.lexeme != ';')) {
  +      // This error is also reported in BodyBuilder.finishFunction
  +      Token bodyToken = body.beginToken ?? modifiers.constKeyword;
  +      handleRecoverableError(
  +          messageConstConstructorWithBody, bodyToken, bodyToken);
  +    }
  +    if (returnType != null) {
  +      // This error is also reported in OutlineBuilder.endMethod
  +      handleRecoverableError(messageConstructorWithReturnType,
  +          returnType.beginToken, returnType.beginToken);
  +    }
  +    ConstructorDeclaration constructor = ast.constructorDeclaration(
  +        comment,
  +        metadata,
  +        modifiers?.externalKeyword,
  +        modifiers?.finalConstOrVarKeyword,
  +        null,
  +        // TODO(paulberry): factoryKeyword
  +        ast.simpleIdentifier(prefixOrName.token),
  +        period,
  +        nameOrNull,
  +        parameters,
  +        separator,
  +        initializers,
  +        redirectedConstructor,
  +        body);
  +    currentDeclarationMembers.add(constructor);
  +    if (mixinDeclaration != null) {
  +      // TODO (danrubel): Report an error if this is a mixin declaration.
  +    }
  +  }
  +
  +  @override
     void endClassDeclaration(Token beginToken, Token endToken) {
       debugEvent("ClassDeclaration");
       classDeclaration = null;
  -  }
  -
  -  @override
  -  void endClassOrMixinBody(DeclarationKind kind, int memberCount,
  -      Token leftBracket, Token rightBracket) {
  -    // TODO(danrubel): consider renaming endClassOrMixinBody
  -    // to endClassOrMixinOrExtensionBody
  -    assert(optional('{', leftBracket));
  -    assert(optional('}', rightBracket));
  -    debugEvent("ClassOrMixinBody");
  -
  -    if (classDeclaration != null) {
  -      classDeclaration
  -        ..leftBracket = leftBracket
  -        ..rightBracket = rightBracket;
  -    } else if (mixinDeclaration != null) {
  -      mixinDeclaration
  -        ..leftBracket = leftBracket
  -        ..rightBracket = rightBracket;
  -    } else {
  -      extensionDeclaration
  -        ..leftBracket = leftBracket
  -        ..rightBracket = rightBracket;
  -    }
  -  }
  -
  -  @override
  -  void endCombinators(int count) {
  -    debugEvent("Combinators");
  -    push(popTypedList<Combinator>(count) ?? NullValue.Combinators);
  -  }
  -
  -  @override
  -  void endCompilationUnit(int count, Token endToken) {
  -    debugEvent("CompilationUnit");
  -
  -    Token beginToken = pop();
  -    checkEmpty(endToken.charOffset);
  -
  -    CompilationUnitImpl unit = ast.compilationUnit(
  -        beginToken: beginToken,
  -        scriptTag: scriptTag,
  -        directives: directives,
  -        declarations: declarations,
  -        endToken: endToken,
  -        featureSet: _featureSet) as CompilationUnitImpl;
  -    push(unit);
  -  }
  -
  -  void endConditionalExpression(Token question, Token colon) {
  -    assert(optional('?', question));
  -    assert(optional(':', colon));
  -    debugEvent("ConditionalExpression");
  -
  -    Expression elseExpression = pop();
  -    Expression thenExpression = pop();
  -    Expression condition = pop();
  -    reportErrorIfSuper(elseExpression);
  -    reportErrorIfSuper(thenExpression);
  -    push(ast.conditionalExpression(
  -        condition, question, thenExpression, colon, elseExpression));
  -  }
  -
  -  void endConditionalUri(Token ifKeyword, Token leftParen, Token equalSign) {
  -    assert(optional('if', ifKeyword));
  -    assert(optionalOrNull('(', leftParen));
  -    assert(optionalOrNull('==', equalSign));
  -    debugEvent("ConditionalUri");
  -
  -    StringLiteral libraryUri = pop();
  -    StringLiteral value = popIfNotNull(equalSign);
  -    if (value is StringInterpolation) {
  -      for (var child in value.childEntities) {
  -        if (child is InterpolationExpression) {
  -          // This error is reported in OutlineBuilder.endLiteralString
  -          handleRecoverableError(
  -              messageInterpolationInUri, child.beginToken, child.endToken);
  -          break;
  -        }
  -      }
  -    }
  -    DottedName name = pop();
  -    push(ast.configuration(ifKeyword, leftParen, name, equalSign, value,
  -        leftParen?.endGroup, libraryUri));
  -  }
  -
  -  @override
  -  void endConditionalUris(int count) {
  -    debugEvent("ConditionalUris");
  -
  -    push(popTypedList<Configuration>(count) ?? NullValue.ConditionalUris);
  -  }
  -
  -  @override
  -  void endConstExpression(Token constKeyword) {
  -    assert(optional('const', constKeyword));
  -    debugEvent("ConstExpression");
  -
  -    _handleInstanceCreation(constKeyword);
  -  }
  -
  -  @override
  -  void endConstLiteral(Token token) {
  -    debugEvent("endConstLiteral");
  -  }
  -
  -  @override
  -  void endConstructorReference(
  -      Token start, Token periodBeforeName, Token endToken) {
  -    assert(optionalOrNull('.', periodBeforeName));
  -    debugEvent("ConstructorReference");
  -
  -    SimpleIdentifier constructorName = pop();
  -    TypeArgumentList typeArguments = pop();
  -    Identifier typeNameIdentifier = pop();
  -    push(ast.constructorName(ast.typeName(typeNameIdentifier, typeArguments),
  -        periodBeforeName, constructorName));
  -  }
  -
  -  @override
  -  void endDoWhileStatement(
  -      Token doKeyword, Token whileKeyword, Token semicolon) {
  -    assert(optional('do', doKeyword));
  -    assert(optional('while', whileKeyword));
  -    assert(optional(';', semicolon));
  -    debugEvent("DoWhileStatement");
  -
  -    ParenthesizedExpression condition = pop();
  -    Statement body = pop();
  -    push(ast.doStatement(
  -        doKeyword,
  -        body,
  -        whileKeyword,
  -        condition.leftParenthesis,
  -        condition.expression,
  -        condition.rightParenthesis,
  -        semicolon));
  -  }
  -
  -  @override
  -  void endDoWhileStatementBody(Token token) {
  -    debugEvent("endDoWhileStatementBody");
  -  }
  -
  -  @override
  -  void endElseStatement(Token token) {
  -    debugEvent("endElseStatement");
  -  }
  -
  -  @override
  -  void endEnum(Token enumKeyword, Token leftBrace, int count) {
  -    assert(optional('enum', enumKeyword));
  -    assert(optional('{', leftBrace));
  -    debugEvent("Enum");
  -
  -    List<EnumConstantDeclaration> constants = popTypedList(count);
  -    SimpleIdentifier name = pop();
  -    List<Annotation> metadata = pop();
  -    Comment comment = _findComment(metadata, enumKeyword);
  -    declarations.add(ast.enumDeclaration(comment, metadata, enumKeyword, name,
  -        leftBrace, constants, leftBrace?.endGroup));
  -  }
  -
  -  void endExport(Token exportKeyword, Token semicolon) {
  -    assert(optional('export', exportKeyword));
  -    assert(optional(';', semicolon));
  -    debugEvent("Export");
  -
  -    List<Combinator> combinators = pop();
  -    List<Configuration> configurations = pop();
  -    StringLiteral uri = pop();
  -    List<Annotation> metadata = pop();
  -    Comment comment = _findComment(metadata, exportKeyword);
  -    directives.add(ast.exportDirective(comment, metadata, exportKeyword, uri,
  -        configurations, combinators, semicolon));
  -  }
  -
  -  @override
  -  void endExtensionDeclaration(
  -      Token extensionKeyword, Token onKeyword, Token token) {
  -    TypeAnnotation type = pop();
  -    extensionDeclaration
  -      ..extendedType = type
  -      ..onKeyword = onKeyword;
  -    extensionDeclaration = null;
     }
   
     @override
  
positive.code:         null,
          redirectedConstructor,
          body));
    }
  
    @override
    void endMixinFactoryMethod(
        Token beginToken, Token factoryKeyword, Token endToken) {
      debugEvent("MixinFactoryMethod");
      endClassFactoryMethod(beginToken, factoryKeyword, endToken);
    }
  
    @override
    void endExtensionFactoryMethod(
        Token beginToken, Token factoryKeyword, Token endToken) {
      assert(optional('factory', factoryKeyword));
      assert(optional(';', endToken) || optional('}', endToken));
      debugEvent("ExtensionFactoryMethod");
  
      Object bodyObject = pop();
      FormalParameterList parameters = pop();
      TypeParameterList typeParameters = pop();
      Object constructorName = pop();
      _Modifiers modifiers = pop();
      List<Annotation> metadata = pop();
  
      FunctionBody body;
      if (bodyObject is FunctionBody) {
        body = bodyObject;
      } else if (bodyObject is _RedirectingFactoryBody) {
        body = ast.emptyFunctionBody(endToken);
      } else {
        // Unhandled situation which should never happen.
        // Since this event handler is just a recovery attempt,
        // don't bother adding this declaration to the AST.
        return;
      }
      Comment comment = _findComment(metadata, beginToken);
  
      assert(parameters != null);
  
      // Constructor declarations within extensions are invalid and the parser
      // has already reported an error at this point, but we include them in as
      // a method declaration in order to get navigation, search, etc.
  
      SimpleIdentifier methodName;
      if (constructorName is SimpleIdentifier) {
        methodName = constructorName;
      } else if (constructorName is PrefixedIdentifier) {
        methodName = constructorName.identifier;
      } else {
        // Unsure what the method name should be in this situation.
        // Since this event handler is just a recovery attempt,
        // don't bother adding this declaration to the AST.
        return;
      }
      currentDeclarationMembers.add(ast.methodDeclaration(
          comment,
          metadata,
          modifiers?.externalKeyword,
          modifiers?.abstractKeyword ?? modifiers?.staticKeyword,
          null, // returnType
          null, // getOrSet
          null, // operatorKeyword
          methodName,
          typeParameters,
          parameters,
          body));
    }
  
    void endFieldInitializer(Token assignment, Token token) {
      assert(optional('=', assignment));
      debugEvent("FieldInitializer");
  
      Expression initializer = pop();
      SimpleIdentifier name = pop();
      push(_makeVariableDeclaration(name, assignment, initializer));
    }
  
    @override
  
negative.code:     if (node is ConstructorName) {
        push(new _ConstructorNameWithInvalidTypeArgs(node, invalidTypeArgs));
      } else {
        throw new UnimplementedError(
            'node is an instance of ${node.runtimeType} in handleInvalidTypeArguments');
      }
    }
  
  