- Allocate symbols for 'get:' and 'set:'

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 1540 matching lines @@
   StorePointer(&raw_ptr()->library_, value.raw());
 }
 
 
 void Class::set_type_parameters(const TypeArguments& value) const {
   StorePointer(&raw_ptr()->type_parameters_, value.raw());
 }
 
 
 intptr_t Class::NumTypeParameters() const {
+  if (type_parameters() == TypeArguments::null()) {
+    return 0;
+  }
   const TypeArguments& type_params = TypeArguments::Handle(type_parameters());
-  if (type_params.IsNull()) {
-    return 0;
-  } else {
-    return type_params.Length();
-  }
+  return type_params.Length();
 }
 
 
 intptr_t Class::NumTypeArguments() const {
   // To work properly, this call requires the super class of this class to be
   // resolved, which is checked by the SuperClass() call.
   Class& cls = Class::Handle(raw());
   if (IsSignatureClass()) {
     const Function& signature_fun = Function::Handle(signature_function());
     if (!signature_fun.is_static() &&
         !signature_fun.HasInstantiatedSignature()) {
       cls = signature_fun.Owner();
     }
   }
   intptr_t num_type_args = NumTypeParameters();
-  const Class& superclass = Class::Handle(cls.SuperClass());
+  cls = cls.SuperClass();
   // Object is its own super class during bootstrap.
-  if (!superclass.IsNull() && (superclass.raw() != raw())) {
-    num_type_args += superclass.NumTypeArguments();
+  if (!cls.IsNull() && (cls.raw() != raw())) {
+    num_type_args += cls.NumTypeArguments();
   }
   return num_type_args;
 }
 
 
 bool Class::HasTypeArguments() const {
   if (!IsSignatureClass() && (is_finalized() || is_prefinalized())) {
     // More efficient than calling NumTypeArguments().
     return type_arguments_field_offset() != kNoTypeArguments;
   } else {
@@ skipping 2238 matching lines @@
                                  const Array& argument_names,
                                  String* error_message) const {
   const int num_named_arguments =
       argument_names.IsNull() ? 0 : argument_names.Length();
   if (!AreValidArgumentCounts(num_arguments,
                               num_named_arguments,
                               error_message)) {
     return false;
   }
   // Verify that all argument names are valid parameter names.
-  String& argument_name = String::Handle();
-  String& parameter_name = String::Handle();
+  Isolate* isolate = Isolate::Current();
+  String& argument_name = String::Handle(isolate);
+  String& parameter_name = String::Handle(isolate);
   for (int i = 0; i < num_named_arguments; i++) {
     argument_name ^= argument_names.At(i);
     ASSERT(argument_name.IsSymbol());
     bool found = false;
     const int num_positional_args = num_arguments - num_named_arguments;
     const int num_parameters = NumParameters();
     for (int j = num_positional_args; !found && (j < num_parameters); j++) {
       parameter_name = ParameterNameAt(j);
       ASSERT(argument_name.IsSymbol());
       if (argument_name.Equals(parameter_name)) {
@@ skipping 809 matching lines @@
   return reinterpret_cast<RawRedirectionData*>(raw);
 }
 
 
 const char* RedirectionData::ToCString() const {
   return "RedirectionData class";
 }
 
 
 RawString* Field::GetterName(const String& field_name) {
-  String& str = String::Handle();
-  str = String::New(kGetterPrefix);
-  str = String::Concat(str, field_name);
-  return str.raw();
+  return String::Concat(Symbols::GetterPrefix(), field_name);
 }
 
 
 RawString* Field::GetterSymbol(const String& field_name) {
   const String& str = String::Handle(Field::GetterName(field_name));
   return Symbols::New(str);
 }
 
 
 RawString* Field::SetterName(const String& field_name) {
-  String& str = String::Handle();
-  str = String::New(kSetterPrefix);
-  str = String::Concat(str, field_name);
-  return str.raw();
+  return String::Concat(Symbols::SetterPrefix(), field_name);
 }
 
 
 RawString* Field::SetterSymbol(const String& field_name) {
   const String& str = String::Handle(Field::SetterName(field_name));
   return Symbols::New(str);
 }
 
 
 RawString* Field::NameFromGetter(const String& getter_name) {
-  String& str = String::Handle();
-  str = String::SubString(getter_name, strlen(kGetterPrefix));
-  return str.raw();
+  return String::SubString(getter_name, strlen(kGetterPrefix));
 }
 
 
 RawString* Field::NameFromSetter(const String& setter_name) {
-  String& str = String::Handle();
-  str = String::SubString(setter_name, strlen(kSetterPrefix));
-  return str.raw();
+  return String::SubString(setter_name, strlen(kSetterPrefix));
 }
 
 
 bool Field::IsGetterName(const String& function_name) {
-  return function_name.StartsWith(String::Handle(String::New(kGetterPrefix)));
+  return function_name.StartsWith(Symbols::GetterPrefix());
 }
 
 
 bool Field::IsSetterName(const String& function_name) {
-  return function_name.StartsWith(String::Handle(String::New(kSetterPrefix)));
+  return function_name.StartsWith(Symbols::SetterPrefix());
 }
 
 
 void Field::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
 RawClass* Field::owner() const {
@@ skipping 1589 matching lines @@
     return Library::null();
   }
   return import.library();
 }
 
 
 RawNamespace* Library::ImportAt(intptr_t index) const {
   if ((index < 0) || index >= num_imports()) {
     return Namespace::null();
   }
+  Namespace& import = Namespace::Handle();

[Ivan Posva, 2013/05/23 22:30:17]

?

[siva, 2013/05/23 22:39:31]

Restored.

   const Array& import_list = Array::Handle(imports());
-  Namespace& import = Namespace::Handle();
   import ^= import_list.At(index);
   return import.raw();
 }
 
 
 bool Library::ImportsCorelib() const {
   Isolate* isolate = Isolate::Current();
   Library& imported = Library::Handle(isolate);
   intptr_t count = num_imports();
   for (int i = 0; i < count; i++) {
@@ skipping 6897 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart