Rename FunctionDeclaration to LocalFunctionDeclaration.

pkg/front_end/lib/src/fasta/parser/parser.dart

 // Copyright (c) 2012, 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.
 
 library fasta.parser.parser;
 
 import '../fasta_codes.dart' show Code, Message, Template;
 
 import '../fasta_codes.dart' as fasta;
 
@@ skipping 1310 matching lines @@
             // `(',' | '=' | ';')`.
 
             // TODO(ahe): Generate type events and call
             // parseVariablesDeclarationRest instead.
             return parseVariablesDeclaration(begin);
           } else if (OPEN_PAREN_TOKEN == afterIdKind) {
             // We are looking at `type identifier '('`.
             if (looksLikeFunctionBody(getClose(afterId).next)) {
               // We are looking at `type identifier '(' ... ')'` followed
               // `( '{' | '=>' | 'async' | 'sync' )`.
-              return parseFunctionDeclaration(begin);
+              return parseLocalFunctionDeclaration(begin);
             }
           } else if (identical(afterIdKind, LT_TOKEN)) {
             // We are looking at `type identifier '<'`.
             Token afterTypeVariables = getClose(afterId)?.next;
             if (afterTypeVariables != null &&
                 optional("(", afterTypeVariables)) {
               if (looksLikeFunctionBody(getClose(afterTypeVariables).next)) {
                 // We are looking at "type identifier '<' ... '>' '(' ... ')'"
                 // followed by '{', '=>', 'async', or 'sync'.
-                return parseFunctionDeclaration(begin);
+                return parseLocalFunctionDeclaration(begin);
               }
             }
           }
           // Fall-through to expression statement.
         } else {
           token = begin;
           if (optional(':', token.next)) {
             return parseLabeledStatement(token);
           } else if (optional('(', token.next)) {
             if (looksLikeFunctionBody(getClose(token.next).next)) {
-              return parseFunctionDeclaration(token);
+              return parseLocalFunctionDeclaration(token);
             }
           } else if (optional('<', token.next)) {
             Token afterTypeVariables = getClose(token.next)?.next;
             if (afterTypeVariables != null &&
                 optional("(", afterTypeVariables)) {
               if (looksLikeFunctionBody(getClose(afterTypeVariables).next)) {
-                return parseFunctionDeclaration(token);
+                return parseLocalFunctionDeclaration(token);
               }
             }
             // Fall through to expression statement.
           }
         }
         return parseExpressionStatement(begin);
 
       case TypeContinuation.ExpressionStatementOrConstDeclaration:
         Token identifier;
         if (looksLikeType && token.isIdentifier) {
@@ skipping 1083 matching lines @@
     token = parseFormalParameters(token, MemberKind.Local);
     AsyncModifier savedAsyncModifier = asyncState;
     token = parseAsyncModifier(token);
     bool isBlock = optional('{', token);
     token = parseFunctionBody(token, true, false);
     asyncState = savedAsyncModifier;
     listener.endFunctionExpression(beginToken, token);
     return isBlock ? token.next : token;
   }
 
-  Token parseFunctionDeclaration(Token token) {
-    listener.beginFunctionDeclaration(token);
+  Token parseLocalFunctionDeclaration(Token token) {
+    listener.beginLocalFunctionDeclaration(token);
     Token beginToken = token;
     token = parseModifiers(token, MemberKind.Local);
     listener.beginFunctionName(token);
     token = parseIdentifier(token, IdentifierContext.localFunctionDeclaration);
     token = parseQualifiedRestOpt(
         token, IdentifierContext.localFunctionDeclarationContinuation);
     listener.endFunctionName(beginToken, token);
     token = parseTypeVariablesOpt(token);
     token = parseFormalParametersOpt(token, MemberKind.Local);
     token = parseInitializersOpt(token);
     AsyncModifier savedAsyncModifier = asyncState;
     token = parseAsyncModifier(token);
     token = parseFunctionBody(token, false, true);
     asyncState = savedAsyncModifier;
     token = token.next;
-    listener.endFunctionDeclaration(token);
+    listener.endLocalFunctionDeclaration(token);
     return token;
   }
 
   /// Parses a named function expression which isn't legal syntax in Dart.
   /// Useful for recovering from Javascript code being pasted into a Dart
   /// proram, as it will interpret `function foo() {}` as a named function
   /// expression with return type `function` and name `foo`.
   Token parseNamedFunctionExpression(Token token) {
     Token beginToken = token;
     listener.beginNamedFunctionExpression(token);
@@ skipping 1644 matching lines @@
   }
 
   Token reportUnexpectedToken(Token token) {
     return reportUnrecoverableErrorWithToken(
         token, fasta.templateUnexpectedToken);
   }
 }
 
 // TODO(ahe): Remove when analyzer supports generalized function syntax.
 typedef _MessageWithArgument<T> = Message Function(T);