Experiment with new function-type syntax.

pkg/analyzer/lib/src/generated/parser.dart

 // Copyright (c) 2014, 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 analyzer.src.generated.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 3946 matching lines @@
 
   /**
    * Parse a normal formal parameter. Return the normal formal parameter that
    * was parsed.
    *
    *     normalFormalParameter ::=
    *         functionSignature
    *       | fieldFormalParameter
    *       | simpleFormalParameter
    *
-   *     functionSignature:
+   *     legacyFunctionSignature:
    *         metadata returnType? identifier typeParameters? formalParameterList
    *
    *     fieldFormalParameter ::=
    *         metadata finalConstVarOrType? 'this' '.' identifier
    *
    *     simpleFormalParameter ::=
    *         declaredIdentifier
    *       | metadata identifier
    */
   NormalFormalParameter parseNormalFormalParameter() {
@@ skipping 838 matching lines @@
    *         classTypeAlias
    *       | functionTypeAlias
    *
    *     classTypeAlias ::=
    *         identifier typeParameters? '=' 'abstract'? mixinApplication
    *
    *     mixinApplication ::=
    *         qualified withClause implementsClause? ';'
    *
    *     functionTypeAlias ::=
+   *         legacyFunctionTypeAlias |
+   *         newFunctionTypeAlias
+   *
+   *     legacyFunctionTypeAlias ::=
    *         functionPrefix typeParameterList? formalParameterList ';'
    *
    *     functionPrefix ::=
    *         returnType? name
+   *
+   *     newFunctionTypeAlias ::=
+   *         identifier typeParameters? '=' functionType ';'
+   *
+   *     functionType ::= typeParameterList? formalParameterList '-' '>' returnType

[Lasse Reichstein Nielsen, 2016/10/20 19:36:44]

I assume you use '-' '>' instead of '->' because it's easier than introducing a
new token?

[floitsch, 2016/10/21 12:24:34]

correct.

+   *
    */
   TypeAlias parseTypeAlias(CommentAndMetadata commentAndMetadata) {
     Token keyword = getAndAdvance();
     if (_matchesIdentifier()) {
       Token next = _peek();
       if (_tokenMatches(next, TokenType.LT)) {
         next = _skipTypeParameterList(next);
         if (next != null && _tokenMatches(next, TokenType.EQ)) {
+          next = next.next;
+          if (next != null &&
+              (_tokenMatches(next, TokenType.LT) ||
+                  _tokenMatches(next, TokenType.OPEN_PAREN))) {
+            return _parseNewFunctionTypeAlias(commentAndMetadata, keyword);
+          }
+          if (next != null && _tokenMatches(next, TokenType.IDENTIFIER)) {
+            next = next.next;
+            if (next != null && _tokenMatches(next, TokenType.MINUS)) {
+              return _parseNewFunctionTypeAlias(commentAndMetadata, keyword);
+            }
+          }
           TypeAlias typeAlias =
               parseClassTypeAlias(commentAndMetadata, null, keyword);
           _reportErrorForToken(
               ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS, keyword);
           return typeAlias;
         }
       } else if (_tokenMatches(next, TokenType.EQ)) {
+        next = next.next;
+        if (next != null &&
+            (_tokenMatches(next, TokenType.LT) ||
+                _tokenMatches(next, TokenType.OPEN_PAREN))) {
+          return _parseNewFunctionTypeAlias(commentAndMetadata, keyword);
+        } else if (next != null && _tokenMatches(next, TokenType.IDENTIFIER)) {
+          next = next.next;
+          if (next != null && _tokenMatches(next, TokenType.MINUS)) {
+            return _parseNewFunctionTypeAlias(commentAndMetadata, keyword);
+          }
+        }
         TypeAlias typeAlias =
             parseClassTypeAlias(commentAndMetadata, null, keyword);
         _reportErrorForToken(
             ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS, keyword);
         return typeAlias;
       }
     }
     return _parseFunctionTypeAlias(commentAndMetadata, keyword);
   }
 
@@ skipping 460 matching lines @@
    * a type name or changing the current token. Return the token following the
    * type name that was parsed, or `null` if the given token is not the first
    * token in a valid type name.
    *
    * This method must be kept in sync with [parseTypeName].
    *
    *     type ::=
    *         qualified typeArguments?
    */
   Token skipTypeName(Token startToken) {
-    Token token = skipPrefixedIdentifier(startToken);
+    Token token;
+    if (_tokenMatches(startToken, TokenType.LT)) {
+      token = skipTypeArgumentList(token);
+      if (token == null) return null;
+      token = _skipFormalParameterList(token);
+      if (token == null) return null;
+      if (!_tokenMatches(token, TokenType.MINUS)) return null;
+      token = token.next;
+      if (token == null) return null;
+      if (!_tokenMatches(token, TokenType.GT)) return null;
+      return skipTypeName(token);
+    }
+
+    token = skipPrefixedIdentifier(startToken);
     if (token == null) {
       return null;
     }
     if (_tokenMatches(token, TokenType.LT)) {
       token = skipTypeArgumentList(token);
     }
     return token;
   }
 
   /**
@@ skipping 1174 matching lines @@
         _reportErrorForToken(
             ParserErrorCode.GETTER_IN_FUNCTION, propertyKeyword);
       } else {
         _reportErrorForToken(
             ParserErrorCode.SETTER_IN_FUNCTION, propertyKeyword);
       }
     }
     return new FunctionDeclarationStatement(declaration);
   }
 
+  FunctionTypeAlias _parseNewFunctionTypeAlias(CommentAndMetadata commentAndMetadata, Token keyword) {
+    SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
+    TypeParameterList typeParameters = null;
+    if (_matches(TokenType.LT)) {
+      typeParameters = parseTypeParameterList();
+    }
+
+    _expect(TokenType.EQ);  // TODO(floitsch): store the sign in the node.
+
+    if (_matches(TokenType.LT)) {
+      parseTypeParameterList();  // TODO(floitsch): store the generic arguments.
+    }
+
+
+    TokenType type = _currentToken.type;
+
+    if (type == TokenType.OPEN_PAREN || type == TokenType.IDENTIFIER) {
+      FormalParameterList parameters;
+      if (type == TokenType.OPEN_PAREN) {
+        parameters = _parseFormalParameterListUnchecked();

[Lasse Reichstein Nielsen, 2016/10/20 19:36:44]

Using the old formal-parameter list, so a single identifier is a name, not a
type, right?

[floitsch, 2016/10/21 12:24:34]

Right.

I wanted to see how hard it would be to change the parser. Resolving it the
right way shouldn't be too hard, once the parser has constructed the nodes.

+      } else {
+        var parameter = parseNormalFormalParameter();
+        parameters = new FormalParameterList(
+            _createSyntheticToken(TokenType.OPEN_PAREN),
+            [parameter], null, null,
+            _createSyntheticToken(TokenType.CLOSE_PAREN));
+      }
+      _validateFormalParameterList(parameters);
+
+      _expect(TokenType.MINUS);
+      _expect(TokenType.GT);
+
+      TypeName returnType = parseReturnType();
+
+      Token semicolon = _expect(TokenType.SEMICOLON);
+      return new FunctionTypeAlias(
+          commentAndMetadata.comment,
+          commentAndMetadata.metadata,
+          keyword,
+          returnType,
+          name,
+          typeParameters,
+          parameters,
+          semicolon);
+    } else {
+      _reportErrorForCurrentToken(ParserErrorCode.MISSING_TYPEDEF_PARAMETERS);
+      // Recovery: At the very least we should skip to the start of the next
+      // valid compilation unit member, allowing for the possibility of finding
+      // the typedef parameters before that point.
+      return new FunctionTypeAlias(
+          commentAndMetadata.comment,
+          commentAndMetadata.metadata,
+          keyword,
+          null,
+          name,
+          typeParameters,
+          new FormalParameterList(_createSyntheticToken(TokenType.OPEN_PAREN),
+              null, null, null, _createSyntheticToken(TokenType.CLOSE_PAREN)),
+          _createSyntheticToken(TokenType.SEMICOLON));
+    }
+  }
+
   /**
    * Parse a function type alias. The [commentAndMetadata] is the metadata to be
    * associated with the member. The [keyword] is the token representing the
    * 'typedef' keyword. Return the function type alias that was parsed.
    *
    *     functionTypeAlias ::=
    *         functionPrefix typeParameterList? formalParameterList ';'
    *
    *     functionPrefix ::=
    *         returnType? name
@@ skipping 694 matching lines @@
     }
     _errorListener.onError(error);
   }
 
   /**
    * Report an error with the given [errorCode] and [arguments] associated with
    * the current token.
    */
   void _reportErrorForCurrentToken(ParserErrorCode errorCode,
       [List<Object> arguments]) {
+    print("error ${StackTrace.current}");
     _reportErrorForToken(errorCode, _currentToken, arguments);
   }
 
   /**
    * Report an error with the given [errorCode] and [arguments] associated with
    * the given [node].
    */
   void _reportErrorForNode(ParserErrorCode errorCode, AstNode node,
       [List<Object> arguments]) {
     _reportError(new AnalysisError(
@@ skipping 855 matching lines @@
    */
   Parser_SyntheticKeywordToken(Keyword keyword, int offset)
       : super(keyword, offset);
 
   @override
   int get length => 0;
 
   @override
   Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
 }