Implement generic function type syntax in the VM (fixes #27966).

runtime/vm/parser.h

 // 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.
 
 #ifndef RUNTIME_VM_PARSER_H_
 #define RUNTIME_VM_PARSER_H_
 
 #include "include/dart_api.h"
 
 #include "platform/assert.h"
@@ skipping 385 matching lines @@
   bool IsYieldKeyword();
 
   void SkipIf(Token::Kind);
   void SkipToMatching();
   void SkipToMatchingParenthesis();
   void SkipBlock();
   TokenPosition SkipMetadata();
   bool IsPatchAnnotation(TokenPosition pos);
   void SkipTypeArguments();
   void SkipType(bool allow_void);
+  void SkipTypeOrFunctionType(bool allow_void);
   void SkipInitializers();
   void SkipExpr();
   void SkipNestedExpr();
   void SkipConditionalExpr();
   void SkipBinaryExpr();
   void SkipUnaryExpr();
   void SkipPostfixExpr();
   void SkipSelectors();
   void SkipPrimary();
   void SkipCompoundLiteral();
@@ skipping 90 matching lines @@
   void ParseLibraryDefinition(const Object& tl_owner);
   void ParseLibraryName();
   void ParseLibraryImportExport(const Object& tl_owner,
                                 TokenPosition metadata_pos);
   void ParseLibraryPart();
   void ParsePartHeader();
   void ParseLibraryNameObsoleteSyntax();
   void ParseLibraryImportObsoleteSyntax();
   void ParseLibraryIncludeObsoleteSyntax();
 
+  void ResolveSignature(ClassFinalizer::FinalizationKind finalization,
+                        const Function& signature);
   void ResolveType(ClassFinalizer::FinalizationKind finalization,
                    AbstractType* type);
   RawAbstractType* ParseType(ClassFinalizer::FinalizationKind finalization,
                              bool allow_deferred_type = false,
                              bool consume_unresolved_prefix = true);
   RawAbstractType* ParseType(ClassFinalizer::FinalizationKind finalization,
                              bool allow_deferred_type,
                              bool consume_unresolved_prefix,
                              LibraryPrefix* prefix);
-
+  RawType* ParseFunctionType(const AbstractType& result_type,
+                             ClassFinalizer::FinalizationKind finalization);
+  RawAbstractType* ParseTypeOrFunctionType(
+      bool allow_void,
+      ClassFinalizer::FinalizationKind finalization);
   void ParseTypeParameters(bool parameterizing_class);
   RawTypeArguments* ParseTypeArguments(
       ClassFinalizer::FinalizationKind finalization);
   void ParseMethodOrConstructor(ClassDesc* members, MemberDesc* method);
   void ParseFieldDefinition(ClassDesc* members, MemberDesc* field);
   void CheckMemberNameConflict(ClassDesc* members, MemberDesc* member);
   void ParseClassMemberDefinition(ClassDesc* members,
                                   TokenPosition metadata_pos);
-  void ParseFormalParameter(bool allow_explicit_default_value,
+  void ParseFormalParameter(bool use_function_type_syntax,
+                            bool allow_explicit_default_value,
                             bool evaluate_metadata,
                             ParamList* params);
-  void ParseFormalParameters(bool allow_explicit_default_values,
+  void ParseFormalParameters(bool use_function_type_syntax,
+                             bool allow_explicit_default_values,
                              bool evaluate_metadata,
                              ParamList* params);
-  void ParseFormalParameterList(bool allow_explicit_default_values,
+  void ParseFormalParameterList(bool use_function_type_syntax,
+                                bool allow_explicit_default_values,
                                 bool evaluate_metadata,
                                 ParamList* params);
   void CheckFieldsInitialized(const Class& cls);
   void AddImplicitConstructor(const Class& cls);
   void CheckConstructors(ClassDesc* members);
   AstNode* ParseExternalInitializedField(const Field& field);
   void ParseInitializedInstanceFields(
       const Class& cls,
       LocalVariable* receiver,
       GrowableArray<Field*>* initialized_fields);
@@ skipping 43 matching lines @@
                                  TokenPosition field_pos);
   AstNode* ParseSuperOperator();
   AstNode* BuildUnarySuperOperator(Token::Kind op, PrimaryNode* super);
 
   static bool ParseFormalParameters(const Function& func, ParamList* params);
 
   void SetupDefaultsForOptionalParams(const ParamList& params);
   ClosureNode* CreateImplicitClosureNode(const Function& func,
                                          TokenPosition token_pos,
                                          AstNode* receiver);
+  void FinalizeFormalParameterTypes(const ParamList* params);
   void AddFormalParamsToFunction(const ParamList* params, const Function& func);
   void AddFormalParamsToScope(const ParamList* params, LocalScope* scope);
 
   SequenceNode* ParseConstructor(const Function& func);
   SequenceNode* ParseFunc(const Function& func, bool check_semicolon);
 
   void ParseNativeFunctionBlock(const ParamList* params, const Function& func);
 
   SequenceNode* ParseInstanceGetter(const Function& func);
   SequenceNode* ParseInstanceSetter(const Function& func);
@@ skipping 128 matching lines @@
   AstNode* ParseVariableDeclarationList();
   AstNode* ParseFunctionStatement(bool is_literal);
   AstNode* ParseYieldStatement();
   AstNode* ParseStatement();
   SequenceNode* ParseNestedStatement(bool parsing_loop_body,
                                      SourceLabel* label);
   void ParseStatementSequence();
   bool IsIdentifier();
   bool IsSymbol(const String& symbol);
   bool IsSimpleLiteral(const AbstractType& type, Instance* value);
-  bool IsFunctionTypeAliasName();
+  bool IsFunctionTypeSymbol();
+  bool IsFunctionTypeAliasName(bool* use_function_type_syntax);
   bool TryParseQualIdent();
   bool TryParseTypeParameters();
   bool TryParseTypeArguments();
   bool IsTypeParameters();
   bool IsArgumentPart();
   bool IsParameterPart();
-  bool TryParseOptionalType();
-  bool TryParseReturnType();
+  bool TryParseType(bool allow_void);
   bool IsVariableDeclaration();
   bool IsFunctionReturnType();
   bool IsFunctionDeclaration();
   bool IsFunctionLiteral();
   bool IsForInStatement();
   bool IsTopLevelAccessor();
 
   AstNode* ParseBinaryExpr(int min_preced);
   LiteralNode* ParseConstExpr();
   static const bool kRequireConst = true;
@@ skipping 203 matching lines @@
 
   intptr_t recursion_counter_;
   friend class RecursionChecker;
 
   DISALLOW_COPY_AND_ASSIGN(Parser);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_PARSER_H_