Add metadata for type parameters (TypeVariableMirror).

runtime/vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 6528 matching lines @@
 
 static RawString* MakeFunctionMetaName(const Function& func) {
   const String& cname =
       String::Handle(MakeClassMetaName(Class::Handle(func.origin())));
   String& fname = String::Handle(func.name());
   fname = String::Concat(Symbols::At(), fname);
   return String::Concat(cname, fname);
 }
 
 
+static RawString* MakeTypeParameterMetaName(const TypeParameter& param) {
+  const String& cname = String::Handle(
+      MakeClassMetaName(Class::Handle(param.parameterized_class())));
+  String& pname = String::Handle(param.name());
+  // We need to choose something different from field/function names, because it
+  // is allowed to have type parameters and fields/functions with the same name
+  // in a class.
+  pname = String::Concat(Symbols::Slash(), pname);
+  return String::Concat(cname, pname);

[siva, 2013/09/14 00:58:41]

Why not create an array and invoke String::ConcatAll

String name = String::Handle();
Array parts = Array::Handle(Array::New(3));
name = MakeClassMetaName(.....);
array.SetAt(0,  name);
array.SetAt(1, Symbols::Slash());
name = param.name();
array.SetAt(2, name);
return String::ConcatAll(parts);

[Michael Lippautz (Google), 2013/09/16 16:44:35]

Sure. Done.

+}
+
+
 void Library::AddMetadata(const Class& cls,
                           const String& name,
                           intptr_t token_pos) const {
   const String& metaname = String::Handle(Symbols::New(name));
   Field& field = Field::Handle(Field::New(metaname,
                                           true,   // is_static
                                           false,  // is_final
                                           false,  // is_const
                                           cls,
                                           token_pos));
@@ skipping 18 matching lines @@
 }
 
 
 void Library::AddFunctionMetadata(const Function& func,
                                   intptr_t token_pos) const {
   AddMetadata(Class::Handle(func.origin()),
               String::Handle(MakeFunctionMetaName(func)),
               token_pos);
 }
 
+
+void Library::AddTypeParameterMetadata(const TypeParameter& param,
+                                       intptr_t token_pos) const {
+  AddMetadata(Class::Handle(param.parameterized_class()),
+              String::Handle(MakeTypeParameterMetaName(param)),
+              token_pos);
+}
+
+
 void Library::AddLibraryMetadata(const Class& cls, intptr_t token_pos) const {
   AddMetadata(cls, Symbols::TopLevel(), token_pos);
 }
 
 
 RawString* Library::MakeMetadataName(const Object& obj) const {
   if (obj.IsClass()) {
     return MakeClassMetaName(Class::Cast(obj));
   } else if (obj.IsField()) {
     return MakeFieldMetaName(Field::Cast(obj));
   } else if (obj.IsFunction()) {
     return MakeFunctionMetaName(Function::Cast(obj));
   } else if (obj.IsLibrary()) {
     return Symbols::TopLevel().raw();
+  } else if (obj.IsTypeParameter()) {
+    return MakeTypeParameterMetaName(TypeParameter::Cast(obj));
   }
   UNIMPLEMENTED();
   return String::null();
 }
 
 
 RawField* Library::GetMetadataField(const String& metaname) const {
   const GrowableObjectArray& metadata =
       GrowableObjectArray::Handle(this->metadata());
   Field& entry = Field::Handle();
   String& entryname = String::Handle();
   intptr_t num_entries = metadata.Length();
   for (intptr_t i = 0; i < num_entries; i++) {
     entry ^= metadata.At(i);
     entryname = entry.name();
     if (entryname.Equals(metaname)) {
       return entry.raw();
     }
   }
   return Field::null();
 }
 
 
 RawObject* Library::GetMetadata(const Object& obj) const {
   if (!obj.IsClass() && !obj.IsField() && !obj.IsFunction() &&
-      !obj.IsLibrary()) {
+      !obj.IsLibrary() && !obj.IsTypeParameter()) {
     return Object::null();
   }
   const String& metaname = String::Handle(MakeMetadataName(obj));
   Field& field = Field::Handle(GetMetadataField(metaname));
   if (field.IsNull()) {
     // There is no metadata for this object.
     return Object::empty_array().raw();;
   }
   Object& metadata = Object::Handle();
   metadata = field.value();
@@ skipping 8248 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart