anchor.diff:  
               // TODO(ahe): Generate type events and call
               // parseVariablesDeclarationRest instead.
  -            // TODO(brianwilkerson): Remove the invocation of `previous` when
  -            // this method accepts the last consumed token.
  -            return parseVariablesDeclaration(begin.previous);
  +            return parseVariablesDeclaration(beforeBegin);
             }
             // Fall-through to expression statement.
           }
   
  -        return parseExpressionStatement(begin);
  +        return parseExpressionStatement(beforeBegin.next);
   
         case TypeContinuation.SendOrFunctionLiteral:
  +        Token beforeName;
           Token name;
           bool hasReturnType;
           if (looksLikeType && looksLikeFunctionDeclaration(token)) {
  +          beforeName = beforeToken;
             name = token;
             hasReturnType = true;
             // Fall-through to parseNamedFunctionRest below.
           } else if (looksLikeFunctionDeclaration(begin)) {
  +          beforeName = beforeBegin;
             name = begin;
             hasReturnType = false;
             // Fall-through to parseNamedFunctionRest below.
           } else {
  -          return parseSend(begin, continuationContext);
  +          return parseSend(beforeBegin.next, continuationContext);
           }
   
           Token formals = parseTypeVariablesOpt(name);
  
positive.code:       case TypeContinuation.ExpressionStatementOrDeclaration:
          assert(begin.isIdentifier || identical(begin.stringValue, 'void'));
          if (!inPlainSync && optional("await", begin)) {
            return parseExpressionStatement(begin);
          }
  
          if (looksLikeType && token.isIdentifier) {
  
negative.code:               (optional(">", close) || optional(">>", close))) {
              // We found some type arguments.
              typeArguments = token;
              beforeToken = close;
              token = close.next;
            }
          }
  