Implement eager instantiation and canonicalization of type arguments at run

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 266 matching lines @@
   void SkipSymbolLiteral();
   void SkipNewOperator();
   void SkipActualParameters();
   void SkipMapLiteral();
   void SkipListLiteral();
   void SkipFunctionLiteral();
   void SkipStringLiteral();
   void SkipQualIdent();
   void SkipFunctionPreamble();
 
-  void CheckConstructorCallTypeArguments(
-    intptr_t pos,
-    Function& constructor,
-    const AbstractTypeArguments& type_arguments);
+  void CheckConstructorCallTypeArguments(intptr_t pos,
+                                         Function& constructor,
+                                         const TypeArguments& type_arguments);
 
   // A null script means no source and a negative token_pos means no position.
   static RawString* FormatMessage(const Script& script,
                                   intptr_t token_pos,
                                   LanguageError::Kind kind,
                                   const char* format,
                                   va_list args);
 
   // Reports error/warning msg at location of current token in current script.
   void ErrorMsg(const char* msg, ...) PRINTF_ATTRIBUTE(2, 3);
@@ skipping 12 matching lines @@
   // Concatenates two error messages, the previous and the current one.
   void AppendErrorMsg(
       const Error& prev_error, intptr_t token_pos, const char* format, ...)
       PRINTF_ATTRIBUTE(4, 5);
 
   void CheckRecursiveInvocation();
 
   const Instance& EvaluateConstExpr(intptr_t expr_pos, AstNode* expr);
   AstNode* RunStaticFieldInitializer(const Field& field,
                                      intptr_t field_ref_pos);
-  RawObject* EvaluateConstConstructorCall(
-      const Class& type_class,
-      const AbstractTypeArguments& type_arguments,
-      const Function& constructor,
-      ArgumentListNode* arguments);
+  RawObject* EvaluateConstConstructorCall(const Class& type_class,
+                                          const TypeArguments& type_arguments,
+                                          const Function& constructor,
+                                          ArgumentListNode* arguments);
   AstNode* FoldConstExpr(intptr_t expr_pos, AstNode* expr);
 
   // Support for parsing of scripts.
   void ParseTopLevel();
   void ParseClassDeclaration(const GrowableObjectArray& pending_classes,
                              intptr_t metadata_pos);
   void ParseClassDefinition(const Class& cls);
   void ParseMixinAppAlias(const GrowableObjectArray& pending_classes,
                           intptr_t metadata_pos);
   void ParseTypedef(const GrowableObjectArray& pending_classes,
@@ skipping 15 matching lines @@
   void ParsePartHeader();
   void ParseLibraryNameObsoleteSyntax();
   void ParseLibraryImportObsoleteSyntax();
   void ParseLibraryIncludeObsoleteSyntax();
 
   void ResolveTypeFromClass(const Class& cls,
                             ClassFinalizer::FinalizationKind finalization,
                             AbstractType* type);
   RawAbstractType* ParseType(ClassFinalizer::FinalizationKind finalization);
   void ParseTypeParameters(const Class& cls);
-  RawAbstractTypeArguments* ParseTypeArguments(
+  RawTypeArguments* ParseTypeArguments(
       ClassFinalizer::FinalizationKind finalization);
   void ParseQualIdent(QualIdent* qual_ident);
   void ParseMethodOrConstructor(ClassDesc* members, MemberDesc* method);
   void ParseFieldDefinition(ClassDesc* members, MemberDesc* field);
   void CheckMemberNameConflict(ClassDesc* members, MemberDesc* member);
   void ParseClassMemberDefinition(ClassDesc* members,
                                   intptr_t metadata_pos);
   void ParseFormalParameter(bool allow_explicit_default_value,
                             bool evaluate_metadata,
                             ParamList* params);
@@ skipping 171 matching lines @@
   AstNode* ParsePostfixExpr();
   AstNode* ParseSelectors(AstNode* primary, bool is_cascade);
   AstNode* ParseCascades(AstNode* expr);
   AstNode* ParsePrimary();
   AstNode* ParseStringLiteral(bool allow_interpolation);
   String* ParseImportStringLiteral();
   AstNode* ParseCompoundLiteral();
   AstNode* ParseSymbolLiteral();
   AstNode* ParseListLiteral(intptr_t type_pos,
                             bool is_const,
-                            const AbstractTypeArguments& type_arguments);
+                            const TypeArguments& type_arguments);
   AstNode* ParseMapLiteral(intptr_t type_pos,
                            bool is_const,
-                           const AbstractTypeArguments& type_arguments);
+                           const TypeArguments& type_arguments);
   AstNode* ParseNewOperator(Token::Kind op_kind);
 
   // An implicit argument, if non-null, is prepended to the returned list.
   ArgumentListNode* ParseActualParameters(ArgumentListNode* implicit_arguments,
                                           bool require_const);
   AstNode* ParseStaticCall(const Class& cls,
                            const String& method_name,
                            intptr_t ident_pos);
   AstNode* ParseInstanceCall(AstNode* receiver, const String& method_name);
   AstNode* ParseClosureCall(AstNode* closure);
@@ skipping 68 matching lines @@
   void EnsureSavedCurrentContext();
   bool IsLegalAssignableSyntax(AstNode* expr, intptr_t end_pos);
   AstNode* CreateAssignmentNode(AstNode* original,
                                 AstNode* rhs,
                                 const String* left_ident,
                                 intptr_t left_pos);
   AstNode* InsertClosureCallNodes(AstNode* condition);
 
   ConstructorCallNode* CreateConstructorCallNode(
       intptr_t token_pos,
-      const AbstractTypeArguments& type_arguments,
+      const TypeArguments& type_arguments,
       const Function& constructor,
       ArgumentListNode* arguments);
 
   void AddEqualityNullCheck();
 
   RawInstance* TryCanonicalize(const Instance& instance, intptr_t token_pos);
 
   Isolate* isolate() const { return isolate_; }
 
   Isolate* isolate_;  // Cached current isolate.
@@ skipping 50 matching lines @@
   intptr_t last_used_try_index_;
 
   bool unregister_pending_function_;
 
   DISALLOW_COPY_AND_ASSIGN(Parser);
 };
 
 }  // namespace dart
 
 #endif  // VM_PARSER_H_