anchor.diff:      SimpleIdentifier identifier = pop();
       // TODO(ahe): Don't push initializers, instead install them.
       push(_makeVariableDeclaration(identifier, assignmentOperator, initializer));
  -  }
  -
  -  VariableDeclaration _makeVariableDeclaration(
  -      SimpleIdentifier name, Token equals, Expression initializer) {
  -    var variableDeclaration =
  -        ast.variableDeclaration(name, equals, initializer);
  -    localDeclarations[name.offset] = variableDeclaration;
  -    return variableDeclaration;
  -  }
  -
  -  @override
  -  void endWhileStatement(Token whileKeyword, Token endToken) {
  -    assert(optional('while', whileKeyword));
  -    debugEvent("WhileStatement");
  -
  -    Statement body = pop();
  -    ParenthesizedExpression condition = pop();
  -    push(ast.whileStatement(whileKeyword, condition.leftParenthesis,
  -        condition.expression, condition.rightParenthesis, body));
  -  }
  -
  -  @override
  -  void endYieldStatement(Token yieldToken, Token starToken, Token semicolon) {
  -    assert(optional('yield', yieldToken));
  -    assert(optionalOrNull('*', starToken));
  -    assert(optional(';', semicolon));
  -    debugEvent("YieldStatement");
  -
  -    Expression expression = pop();
  -    push(ast.yieldStatement(yieldToken, starToken, expression, semicolon));
  -  }
  -
  -  @override
  -  void handleNoVariableInitializer(Token token) {
  -    debugEvent("NoVariableInitializer");
  -  }
  -
  -  void endInitializedIdentifier(Token nameToken) {
  -    debugEvent("InitializedIdentifier");
  -
  -    AstNode node = pop();
  -    VariableDeclaration variable;
  -    // TODO(paulberry): This seems kludgy.  It would be preferable if we
  -    // could respond to a "handleNoVariableInitializer" event by converting a
  -    // SimpleIdentifier into a VariableDeclaration, and then when this code was
  -    // reached, node would always be a VariableDeclaration.
  -    if (node is VariableDeclaration) {
  -      variable = node;
  -    } else if (node is SimpleIdentifier) {
  -      variable = _makeVariableDeclaration(node, null, null);
  -    } else {
  -      unhandled("${node.runtimeType}", "identifier", nameToken.charOffset, uri);
  -    }
  -    push(variable);
  -  }
  -
  -  @override
  -  void beginVariablesDeclaration(Token token, Token varFinalOrConst) {
  -    debugEvent("beginVariablesDeclaration");
  -    if (varFinalOrConst != null) {
  -      push(new _Modifiers()..finalConstOrVarKeyword = varFinalOrConst);
  -    } else {
  -      push(NullValue.Modifiers);
  -    }
     }
   
     @override
  
positive.code:         semicolon));
    }
  
    void handleAssignmentExpression(Token token) {
      assert(token.type.isAssignmentOperator);
      debugEvent("AssignmentExpression");
  
negative.code:   }
  
    @override
    void handleNativeClause(Token nativeToken, bool hasName) {
      debugEvent("NativeClause");
  
      if (hasName) {
        nativeName = pop(); // StringLiteral
      } else {
        nativeName = null;
      }
    }
  
    @override
    void handleNativeFunctionBody(Token nativeToken, Token semicolon) {
      assert(optional('native', nativeToken));
      assert(optional(';', semicolon));
      debugEvent("NativeFunctionBody");
  
      // TODO(danrubel) Change the parser to not produce these modifiers.
      pop(); // star
      pop(); // async
      push(ast.nativeFunctionBody(nativeToken, nativeName, semicolon));
    }
  
    @override
    void handleNoConstructorReferenceContinuationAfterTypeArguments(Token token) {
      debugEvent("NoConstructorReferenceContinuationAfterTypeArguments");
  
      push(NullValue.ConstructorReferenceContinuationAfterTypeArguments);
    }
  
    @override
    void handleNoFieldInitializer(Token token) {
      debugEvent("NoFieldInitializer");
  
      SimpleIdentifier name = pop();
      push(_makeVariableDeclaration(name, null, null));
    }
  
    void handleNoInitializers() {
      debugEvent("NoInitializers");
  
      if (!isFullAst) return;
      push(NullValue.ConstructorInitializerSeparator);
      push(NullValue.ConstructorInitializers);
    }
  
    @override
    void handleNonNullAssertExpression(Token bang) {
      debugEvent('NonNullAssertExpression');
      if (!enableNonNullable) {
        reportNonNullAssertExpressionNotEnabled(bang);
      } else {
        push(ast.postfixExpression(pop(), bang));
      }
    }
  
    @override
    void handleNoVariableInitializer(Token token) {
      debugEvent("NoVariableInitializer");
    }
  
    void handleOperator(Token operatorToken) {
      assert(operatorToken.isUserDefinableOperator);
      debugEvent("Operator");
  
      push(operatorToken);
    }
  
    @override
    void handleOperatorName(Token operatorKeyword, Token token) {
      assert(optional('operator', operatorKeyword));
      assert(token.type.isUserDefinableOperator);
      debugEvent("OperatorName");
  
      push(new _OperatorName(
          operatorKeyword, ast.simpleIdentifier(token, isDeclaration: true)));
    }
  
    @override
    void handleParenthesizedCondition(Token leftParenthesis) {
      // TODO(danrubel): Implement rather than forwarding.
      handleParenthesizedExpression(leftParenthesis);
    }
  
    @override
    void handleParenthesizedExpression(Token leftParenthesis) {
      assert(optional('(', leftParenthesis));
      debugEvent("ParenthesizedExpression");
  
      Expression expression = pop();
      push(ast.parenthesizedExpression(
          leftParenthesis, expression, leftParenthesis?.endGroup));
    }
  
    @override
  