Support generic method syntax (fixes #25869).

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 VM_PARSER_H_
 #define VM_PARSER_H_
 
 #include "include/dart_api.h"
 
 #include "platform/assert.h"
@@ skipping 492 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 ResolveTypeFromClass(const Class& cls,
-                            ClassFinalizer::FinalizationKind finalization,
-                            AbstractType* type);
+  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);
 
-  void ParseTypeParameters(const Class& cls);
+  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,
                             bool evaluate_metadata,
                             ParamList* params);
@@ skipping 118 matching lines @@
 
   void AddAsyncClosureParameters(ParamList* params);
   void AddContinuationVariables();
   void AddAsyncClosureVariables();
   void AddAsyncGeneratorVariables();
 
   LocalVariable* LookupReceiver(LocalScope* from_scope, bool test_only);
   LocalVariable* LookupTypeArgumentsParameter(LocalScope* from_scope,
                                               bool test_only);
   void CaptureInstantiator();
+  void CaptureFunctionInstantiator();
   AstNode* LoadReceiver(TokenPosition token_pos);
   AstNode* LoadFieldIfUnresolved(AstNode* node);
   AstNode* LoadClosure(PrimaryNode* primary);
+  AstNode* LoadTypeParameter(PrimaryNode* primary);
   InstanceGetterNode* CallGetter(TokenPosition token_pos,
                                  AstNode* object,
                                  const String& name);
 
   AstNode* ParseAssertStatement(bool is_const = false);
   AstNode* ParseJump(String* label_name);
   AstNode* ParseIfStatement(String* label_name);
   AstNode* ParseWhileStatement(String* label_name);
   AstNode* ParseDoWhileStatement(String* label_name);
   AstNode* ParseForStatement(String* label_name);
@@ skipping 142 matching lines @@
                                      TokenPosition ident_pos);
 
   LocalVariable* LookupLocalScope(const String& ident);
   void CheckInstanceFieldAccess(TokenPosition field_pos,
                                 const String& field_name);
   bool ParsingStaticMember() const;
   const AbstractType* ReceiverType(const Class& cls);
   bool IsInstantiatorRequired() const;
   bool ResolveIdentInLocalScope(TokenPosition ident_pos,
                                 const String &ident,
-                                AstNode** node);
+                                AstNode** node,
+                                intptr_t* function_level);
   static const bool kResolveLocally = true;
   static const bool kResolveIncludingImports = false;
 
   // Resolve a primary identifier in the library or prefix scope and
   // generate the corresponding AstNode.
   AstNode* ResolveIdentInCurrentLibraryScope(TokenPosition ident_pos,
                                              const String& ident);
   AstNode* ResolveIdentInPrefixScope(TokenPosition ident_pos,
                                      const LibraryPrefix& prefix,
                                      const String& ident);
@@ skipping 133 matching lines @@
 
   intptr_t recursion_counter_;
   friend class RecursionChecker;
 
   DISALLOW_COPY_AND_ASSIGN(Parser);
 };
 
 }  // namespace dart
 
 #endif  // VM_PARSER_H_