Add metadata for type parameters (TypeVariableMirror).

runtime/vm/object.cc

Index: runtime/vm/object.cc
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index bdfac3c04eebfd88df665dccbf890e9f3ad69cd0..9fcb1672a68608d5e196764edd7fca4cde6234d5 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -6546,6 +6546,18 @@ static RawString* MakeFunctionMetaName(const Function& func) {
 }
 
 
+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 {
@@ -6584,6 +6596,15 @@ void Library::AddFunctionMetadata(const Function& 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);
 }
@@ -6598,6 +6619,8 @@ RawString* Library::MakeMetadataName(const Object& obj) const {
     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();
@@ -6623,7 +6646,7 @@ RawField* Library::GetMetadataField(const String& metaname) const {
 
 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));