Various semantic checks on formal parameters.

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
         FastaCode,
         FastaMessage,
         codeAbstractNotSync,
         codeAsciiControlCharacter,
         codeAssertAsExpression,
         codeAssertExtraneousArgument,
         codeAsyncAsIdentifier,
         codeAwaitAsIdentifier,
         codeAwaitForNotAsync,
         codeAwaitNotAsync,
         codeBuiltInIdentifierAsType,
         codeBuiltInIdentifierInDeclaration,
+        codeCatchSyntax,
         codeEmptyNamedParameterList,
         codeEmptyOptionalParameterList,
         codeEncoding,
         codeExpectedBlockToSkip,
         codeExpectedBody,
         codeExpectedButGot,
         codeExpectedClassBody,
         codeExpectedClassBodyToSkip,
         codeExpectedDeclaration,
         codeExpectedExpression,
         codeExpectedFunctionBody,
         codeExpectedIdentifier,
         codeExpectedOpenParens,
         codeExpectedString,
         codeExtraneousModifier,
         codeFactoryNotSync,
+        codeFunctionTypeDefaultValue,
         codeGeneratorReturnsValue,
+        codeGetterWithFormals,
         codeInvalidAwaitFor,
         codeInvalidInlineFunctionType,
         codeInvalidSyncModifier,
         codeInvalidVoid,
+        codeNoFormals,
         codeNonAsciiIdentifier,
         codeNonAsciiWhitespace,
         codeOnlyTry,
         codePositionalParameterWithEquals,
+        codePrivateNamedParameter,
         codeRequiredParameterWithDefault,
         codeSetterNotSync,
         codeStackOverflow,
         codeTypeAfterVar,
         codeTypeRequired,
         codeUnexpectedToken,
         codeUnmatchedToken,
         codeUnspecified,
         codeUnsupportedPrefixPlus,
         codeUnterminatedString,
@@ skipping 653 matching lines @@
     listener.beginFormalParameter(token, memberKind);
 
     bool inFunctionType = memberKind == MemberKind.GeneralizedFunctionType;
     token = parseModifiers(token, memberKind, parameterKind: parameterKind);
     bool isNamedParameter = parameterKind == FormalParameterType.NAMED;
 
     Token thisKeyword = null;
     Token nameToken;
     if (inFunctionType) {
       if (isNamedParameter || token.isIdentifier) {
+        nameToken = token;
         token = parseIdentifier(
             token, IdentifierContext.formalParameterDeclaration);
       } else {
         listener.handleNoName(token);
       }
     } else {
       if (optional('this', token)) {
         thisKeyword = token;
         token = expect('.', token.next);
         nameToken = token;
         token = parseIdentifier(token, IdentifierContext.fieldInitializer);
       } else {
         nameToken = token;
         token = parseIdentifier(
             token, IdentifierContext.formalParameterDeclaration);
       }
     }
+    if (isNamedParameter && nameToken.lexeme.startsWith("_")) {
+      reportRecoverableErrorCode(nameToken, codePrivateNamedParameter);
+    }
 
     token = listener.injectGenericCommentTypeList(token);
     if (optional('(', token)) {
       Token inlineFunctionTypeStart = token;
       listener.beginFunctionTypedFormalParameter(token);
       listener.handleNoTypeVariables(token);
       token = parseFormalParameters(token, MemberKind.FunctionTypedParameter);
       listener.endFunctionTypedFormalParameter(thisKeyword, parameterKind);
       // Generalized function types don't allow inline function types.
       // The following isn't allowed:
@@ skipping 11 matching lines @@
       // Generalized function types don't allow inline function types.
       // The following isn't allowed:
       //    int Function(int bar(String x)).
       if (memberKind == MemberKind.GeneralizedFunctionType) {
         reportRecoverableErrorCode(
             inlineFunctionTypeStart, codeInvalidInlineFunctionType);
       }
     }
     String value = token.stringValue;
     if ((identical('=', value)) || (identical(':', value))) {
-      // TODO(ahe): Validate that these are only used for optional parameters.
       Token equal = token;
       token = parseExpression(token.next);
       listener.handleValuedFormalParameter(equal, token);
       if (parameterKind.isRequired) {
         reportRecoverableErrorCode(equal, codeRequiredParameterWithDefault);
       } else if (parameterKind.isPositional && identical(':', value)) {
         reportRecoverableErrorCode(equal, codePositionalParameterWithEquals);
+      } else if (inFunctionType ||
+          memberKind == MemberKind.FunctionTypeAlias ||
+          memberKind == MemberKind.FunctionTypedParameter) {
+        reportRecoverableErrorCode(equal.next, codeFunctionTypeDefaultValue);
       }
     } else {
       listener.handleFormalParameterWithoutValue(token);
     }
     listener.endFormalParameter(
         thisKeyword, nameToken, parameterKind, memberKind);
     return token;
   }
 
   Token parseOptionalFormalParameters(
@@ skipping 583 matching lines @@
     }
 
     if (type == null) {
       listener.handleNoType(name);
     } else {
       parseReturnTypeOpt(type);
     }
     Token token =
         parseIdentifier(name, IdentifierContext.topLevelFunctionDeclaration);
 
+    bool isGetter = false;
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
+      isGetter = optional("get", getOrSet);
       listener.handleNoTypeVariables(token);
     }
+    checkFormals(isGetter, name, token);
     token = parseFormalParametersOpt(token, MemberKind.TopLevelMethod);
     AsyncModifier savedAsyncModifier = asyncState;
     Token asyncToken = token;
     token = parseAsyncModifier(token);
     if (getOrSet != null && !inPlainSync && optional("set", getOrSet)) {
       reportRecoverableErrorCode(asyncToken, codeSetterNotSync);
     }
     token = parseFunctionBody(token, false, externalModifier != null);
     asyncState = savedAsyncModifier;
     Token endToken = token;
     token = token.next;
     listener.endTopLevelMethod(start, getOrSet, endToken);
     return token;
   }
 
+  void checkFormals(bool isGetter, Token name, Token token) {
+    if (optional("(", token)) {
+      if (isGetter) {
+        reportRecoverableErrorCode(token, codeGetterWithFormals);
+      }
+    } else if (!isGetter) {
+      reportRecoverableErrorCodeWithToken(name, codeNoFormals);
+    }
+  }
+
   /// Looks ahead to find the name of a member. Returns a link of the modifiers,
   /// set/get, (operator) name, and either the start of the method body or the
   /// end of the declaration.
   ///
   /// Examples:
   ///
   ///     int get foo;
   /// results in
   ///     [';', 'foo', 'get', 'int']
   ///
@@ skipping 279 matching lines @@
                   token, codeExtraneousModifier);
             }
             typeRequired = false;
           } else if (optional("const", token)) {
             if (!isVariable) {
               reportRecoverableErrorCodeWithToken(
                   token, codeExtraneousModifier);
             }
             typeRequired = false;
           } else if (optional("static", token)) {
-            if (memberKind == MemberKind.NonStaticMethod) {
+            if (parameterKind != null) {
+              reportRecoverableErrorCodeWithToken(
+                  token, codeExtraneousModifier);
+            } else if (memberKind == MemberKind.NonStaticMethod) {
               memberKind = MemberKind.StaticMethod;
             } else if (memberKind == MemberKind.NonStaticField) {
               memberKind = MemberKind.StaticField;
             } else {
               reportRecoverableErrorCodeWithToken(
                   token, codeExtraneousModifier);
               token = token.next;
               continue;
             }
           } else if (optional("covariant", token)) {
@@ skipping 355 matching lines @@
       if (staticModifier != null) {
         reportRecoverableErrorCodeWithToken(
             staticModifier, codeExtraneousModifier);
       }
     } else {
       token = parseIdentifier(name, IdentifierContext.methodDeclaration);
     }
 
     token = parseQualifiedRestOpt(
         token, IdentifierContext.methodDeclarationContinuation);
+    bool isGetter = false;
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
+      isGetter = optional("get", getOrSet);
       listener.handleNoTypeVariables(token);
     }
+    checkFormals(isGetter, name, token);
     token = parseFormalParametersOpt(
         token,
         staticModifier != null
             ? MemberKind.StaticMethod
             : MemberKind.NonStaticMethod);
     token = parseInitializersOpt(token);
     AsyncModifier savedAsyncModifier = asyncState;
     Token asyncToken = token;
     token = parseAsyncModifier(token);
     if (getOrSet != null && !inPlainSync && optional("set", getOrSet)) {
@@ skipping 1565 matching lines @@
       var onKeyword = null;
       if (identical(value, 'on')) {
         // on qualified catchPart?
         onKeyword = token;
         token = parseType(token.next);
         value = token.stringValue;
       }
       Token catchKeyword = null;
       if (identical(value, 'catch')) {
         catchKeyword = token;
-        // TODO(ahe): Validate the "parameters".
+        Token openParens = catchKeyword.next;
+        Token exceptionName = openParens.next;
+        Token commaOrCloseParens = exceptionName.next;
+        Token traceName = commaOrCloseParens.next;
+        Token closeParens = traceName.next;
+        if (!optional("(", openParens)) {
+          // Handled below by parseFormalParameters.
+        } else if (!exceptionName.isIdentifier) {
+          reportRecoverableErrorCode(exceptionName, codeCatchSyntax);
+        } else if (optional(")", commaOrCloseParens)) {
+          // OK: `catch (identifier)`.
+        } else if (!optional(",", commaOrCloseParens)) {
+          reportRecoverableErrorCode(exceptionName, codeCatchSyntax);
+        } else if (!traceName.isIdentifier) {
+          reportRecoverableErrorCode(exceptionName, codeCatchSyntax);
+        } else if (!optional(")", closeParens)) {
+          reportRecoverableErrorCode(exceptionName, codeCatchSyntax);
+        }
         token = parseFormalParameters(token.next, MemberKind.Catch);
       }
       listener.endCatchClause(token);
       token = parseBlock(token);
       ++catchCount;
       listener.handleCatchBlock(onKeyword, catchKeyword);
       value = token.stringValue; // while condition
     }
 
     Token finallyKeyword = null;
@@ skipping 278 matching lines @@
     return reportUnrecoverableError(
         token, () => code.format(uri, token.charOffset, string));
   }
 }
 
 typedef FastaMessage NoArgument(Uri uri, int charOffset);
 
 typedef FastaMessage TokenArgument(Uri uri, int charOffset, Token token);
 
 typedef FastaMessage StringArgument(Uri uri, int charOffset, String string);