[VM generic function reification] Support generic functions in Invocation class.

runtime/vm/precompiler.cc

 // Copyright (c) 2015, 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.
 
 #include "vm/precompiler.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/branch_optimizer.h"
@@ skipping 258 matching lines @@
   ClassTable* table = thread_->isolate()->class_table();
   Class& cls = Class::Handle(zone);
   AbstractType& cls_type = AbstractType::Handle(zone);
   for (intptr_t cid = kInstanceCid; cid < table->NumCids(); cid++) {
     // Create local zone because deep hierarchies may allocate lots of handles
     // within one iteration of this loop.
     StackZone stack_zone(thread_);
     HANDLESCOPE(thread_);
 
     if (!table->HasValidClassAt(cid)) continue;
+    if (cid == kTypeArgumentsCid) continue;
     if (cid == kVoidCid) continue;
     if (cid == kDynamicCid) continue;
     if (cid == kNullCid) continue;  // Instance is not at Bottom like Null type.
     cls = table->At(cid);
     if (cls.is_abstract()) continue;
     if (cls.is_patch()) continue;
     if (cls.IsTopLevel()) continue;
 
     cls_type = cls.RareType();
     if (cls_type.IsSubtypeOf(type, NULL, NULL, Heap::kNew)) {
@@ skipping 377 matching lines @@
 
   AddSelector(Symbols::Call());  // For speed, not correctness.
 
   // Allocated from C++.
   Class& cls = Class::Handle(Z);
   for (intptr_t cid = kInstanceCid; cid < kNumPredefinedCids; cid++) {
     ASSERT(isolate()->class_table()->IsValidIndex(cid));
     if (!isolate()->class_table()->HasValidClassAt(cid)) {
       continue;
     }
-    if ((cid == kDynamicCid) || (cid == kVoidCid) ||
-        (cid == kFreeListElement) || (cid == kForwardingCorpse)) {
+    if ((cid == kTypeArgumentsCid) || (cid == kDynamicCid) ||
+        (cid == kVoidCid) || (cid == kFreeListElement) ||
+        (cid == kForwardingCorpse)) {
       continue;
     }
     cls = isolate()->class_table()->At(cid);
     AddInstantiatedClass(cls);
   }
 
   AddEntryPoints(vm_entry_points);
   AddEntryPoints(embedder_entry_points);
   const Library& lib = Library::Handle(I->object_store()->root_library());
   const String& name = String::Handle(String::New("main"));
@@ skipping 269 matching lines @@
         }
       } else if (entry.IsField()) {
         // Potential need for field initializer.
         field ^= entry.raw();
         AddField(field);
       } else if (entry.IsInstance()) {
         // Const object, literal or args descriptor.
         instance ^= entry.raw();
         if (entry.IsAbstractType()) {
           AddType(AbstractType::Cast(entry));
+        } else if (entry.IsTypeArguments()) {
+          AddTypeArguments(TypeArguments::Cast(entry));
         } else {
           AddConstObject(instance);
         }
       } else if (entry.IsFunction()) {
         // Local closure function.
         target ^= entry.raw();
         AddFunction(target);
       } else if (entry.IsCode()) {
         target_code ^= entry.raw();
         if (target_code.IsAllocationStubCode()) {
           cls ^= target_code.owner();
           AddInstantiatedClass(cls);
         }
-      } else if (entry.IsTypeArguments()) {
-        AddTypeArguments(TypeArguments::Cast(entry));
       }
     }
   }
 
   const Array& inlined_functions =
       Array::Handle(Z, code.inlined_id_to_function());
   for (intptr_t i = 0; i < inlined_functions.Length(); i++) {
     target ^= inlined_functions.At(i);
     AddTypesOf(target);
   }
@@ skipping 158 matching lines @@
   class ConstObjectVisitor : public ObjectPointerVisitor {
    public:
     ConstObjectVisitor(Precompiler* precompiler, Isolate* isolate)
         : ObjectPointerVisitor(isolate),
           precompiler_(precompiler),
           subinstance_(Object::Handle()) {}
 
     virtual void VisitPointers(RawObject** first, RawObject** last) {
       for (RawObject** current = first; current <= last; current++) {
         subinstance_ = *current;
-        if (subinstance_.IsInstance()) {
+        if (subinstance_.IsTypeArguments()) {
+          precompiler_->AddTypeArguments(TypeArguments::Cast(subinstance_));
+        } else if (subinstance_.IsInstance()) {
           precompiler_->AddConstObject(Instance::Cast(subinstance_));
         }
       }
       subinstance_ = Object::null();
     }
 
    private:
     Precompiler* precompiler_;
     Object& subinstance_;
   };
@@ skipping 2701 matching lines @@
   }
   result[idx++] = NULL;
   renames_map.Release();
 
   return result;
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart