- Create frame work for adding read only handles for symbols in the VM isolate

vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 1571 matching lines @@
   const Class& super_class = Class::Handle(cls.SuperClass());
   // Omit the implicit super() if there is no super class (i.e.
   // we're not compiling class Object), or if the super class is an
   // artificially generated "wrapper class" that has no constructor.
   if (super_class.IsNull() ||
       (super_class.num_native_fields() > 0 &&
        Class::Handle(super_class.SuperClass()).IsObjectClass())) {
     return;
   }
   String& ctor_name = String::Handle(super_class.Name());
-  String& ctor_suffix = String::Handle(Symbols::Dot());
-  ctor_name = String::Concat(ctor_name, ctor_suffix);
+  ctor_name = String::Concat(ctor_name, Symbols::DotHandle());
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // Implicit 'this' parameter is the first argument.
   AstNode* implicit_argument = new LoadLocalNode(supercall_pos, receiver);
   arguments->Add(implicit_argument);
   // Implicit construction phase parameter is second argument.
   AstNode* phase_parameter =
       new LiteralNode(supercall_pos,
                       Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
   arguments->Add(phase_parameter);
   const Function& super_ctor = Function::ZoneHandle(
@@ skipping 19 matching lines @@
 
 AstNode* Parser::ParseSuperInitializer(const Class& cls,
                                        LocalVariable* receiver) {
   TRACE_PARSER("ParseSuperInitializer");
   ASSERT(CurrentToken() == Token::kSUPER);
   const intptr_t supercall_pos = TokenPos();
   ConsumeToken();
   const Class& super_class = Class::Handle(cls.SuperClass());
   ASSERT(!super_class.IsNull());
   String& ctor_name = String::Handle(super_class.Name());
-  String& ctor_suffix = String::Handle(Symbols::Dot());
+  ctor_name = String::Concat(ctor_name, Symbols::DotHandle());
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
-    ctor_suffix = String::Concat(
-        ctor_suffix, *ExpectIdentifier("constructor name expected"));
+    ctor_name = String::Concat(ctor_name,
+                               *ExpectIdentifier("constructor name expected"));
   }
-  ctor_name = String::Concat(ctor_name, ctor_suffix);
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("parameter list expected");
   }
 
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // 'this' parameter is the first argument to super class constructor.
   AstNode* implicit_argument = new LoadLocalNode(supercall_pos, receiver);
   arguments->Add(implicit_argument);
   // Second implicit parameter is the construction phase. We optimistically
   // assume that we can execute both the super initializer and the super
@@ skipping 192 matching lines @@
 }
 
 
 void Parser::ParseConstructorRedirection(const Class& cls,
                                          LocalVariable* receiver) {
   TRACE_PARSER("ParseConstructorRedirection");
   ASSERT(CurrentToken() == Token::kTHIS);
   const intptr_t call_pos = TokenPos();
   ConsumeToken();
   String& ctor_name = String::Handle(cls.Name());
-  String& ctor_suffix = String::Handle(Symbols::Dot());
 
+  ctor_name = String::Concat(ctor_name, Symbols::DotHandle());
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
-    ctor_suffix = String::Concat(
-        ctor_suffix, *ExpectIdentifier("constructor name expected"));
+    ctor_name = String::Concat(ctor_name,
+                               *ExpectIdentifier("constructor name expected"));
   }
-  ctor_name = String::Concat(ctor_name, ctor_suffix);
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("parameter list expected");
   }
 
   ArgumentListNode* arguments = new ArgumentListNode(call_pos);
   // 'this' parameter is the first argument to constructor.
   AstNode* implicit_argument = new LoadLocalNode(call_pos, receiver);
   arguments->Add(implicit_argument);
   // Construction phase parameter is second argument.
   LocalVariable* phase_param = LookupPhaseParameter();
@@ skipping 664 matching lines @@
       // Redirected constructor: either this(...) or this.xxx(...).
       if (method->params.has_field_initializer) {
         // Constructors that redirect to another constructor must not
         // initialize any fields using field initializer parameters.
         ErrorMsg(formal_param_pos, "Redirecting constructor "
                  "may not use field initializer parameters");
       }
       ConsumeToken();  // Colon.
       ExpectToken(Token::kTHIS);
       String& redir_name = String::ZoneHandle(
-          String::Concat(members->class_name(),
-                         String::Handle(Symbols::Dot())));
+          String::Concat(members->class_name(), Symbols::DotHandle()));
       if (CurrentToken() == Token::kPERIOD) {
         ConsumeToken();
         redir_name = String::Concat(redir_name,
             *ExpectIdentifier("constructor name expected"));
       }
       method->redirect_name = &redir_name;
       if (CurrentToken() != Token::kLPAREN) {
         ErrorMsg("'(' expected");
       }
       SkipToMatchingParenthesis();
@@ skipping 385 matching lines @@
                                member.name_pos));
       // The type arguments of the result type are set during finalization.
       member.type = &Type::ZoneHandle(Type::New(result_type_class,
                                                 TypeArguments::Handle(),
                                                 member.name_pos));
     } else if (member.has_static) {
       ErrorMsg(member.name_pos, "constructor cannot be static");
     }
     // We must be dealing with a constructor or named constructor.
     member.kind = RawFunction::kConstructor;
-    String& ctor_suffix = String::ZoneHandle(Symbols::Dot());
+    *member.name = String::Concat(*member.name, Symbols::DotHandle());
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
       ConsumeToken();
       member.constructor_name = ExpectIdentifier("identifier expected");
-      ctor_suffix = String::Concat(ctor_suffix, *member.constructor_name);
+      *member.name = String::Concat(*member.name, *member.constructor_name);
     }
-    *member.name = String::Concat(*member.name, ctor_suffix);
     // Ensure that names are symbols.
     *member.name = Symbols::New(*member.name);
     if (member.type == NULL) {
       ASSERT(!member.has_factory);
       // The body of the constructor cannot modify the type arguments of the
       // constructed instance, which is passed in as a hidden parameter.
       // Therefore, there is no need to set the result type to be checked.
       member.type = &Type::ZoneHandle(Type::DynamicType());
     } else {
       // The type can only be already set in the factory case.
@@ skipping 212 matching lines @@
     }
   }
 }
 
 
 // Add an implicit constructor if no explicit constructor is present.
 void Parser::AddImplicitConstructor(ClassDesc* class_desc) {
   // The implicit constructor is unnamed, has no explicit parameter,
   // and contains a supercall in the initializer list.
   String& ctor_name = String::ZoneHandle(
-    String::Concat(class_desc->class_name(), String::Handle(Symbols::Dot())));
+    String::Concat(class_desc->class_name(), Symbols::DotHandle()));
   ctor_name = Symbols::New(ctor_name);
   // The token position for the implicit constructor is the 'class'
   // keyword of the constructor's class.
   Function& ctor = Function::Handle(
       Function::New(ctor_name,
                     RawFunction::kConstructor,
                     /* is_static = */ false,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
@@ skipping 866 matching lines @@
     CallLibraryTagHandler(kSourceTag, source_pos, canon_url);
   }
 }
 
 
 void Parser::ParseLibraryName() {
   ASSERT(CurrentToken() == Token::kLIBRARY);
   ConsumeToken();
   String& lib_name = *ExpectIdentifier("library name expected");
   if (CurrentToken() == Token::kPERIOD) {
-    const String& dot = String::Handle(Symbols::Dot());
     while (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
-      lib_name = String::Concat(lib_name, dot);
+      lib_name = String::Concat(lib_name, Symbols::DotHandle());
       lib_name = String::Concat(lib_name,
           *ExpectIdentifier("malformed library name"));
     }
     lib_name = Symbols::New(lib_name);
   }
   library_.SetName(lib_name);
   ExpectSemicolon();
 }
 
 
@@ skipping 4777 matching lines @@
   return primary;
 }
 
 
 static const String& BuildConstructorName(const String& type_class_name,
                                           const String* named_constructor) {
   // By convention, the static function implementing a named constructor 'C'
   // for class 'A' is labeled 'A.C', and the static function implementing the
   // unnamed constructor for class 'A' is labeled 'A.'.
   // This convention prevents users from explicitly calling constructors.
-  const String& period = String::Handle(Symbols::Dot());
   String& constructor_name =
-      String::Handle(String::Concat(type_class_name, period));
+      String::Handle(String::Concat(type_class_name, Symbols::DotHandle()));
   if (named_constructor != NULL) {
     constructor_name = String::Concat(constructor_name, *named_constructor);
   }
   return constructor_name;
 }
 
 
 AstNode* Parser::ParseNewOperator() {
   TRACE_PARSER("ParseNewOperator");
   const intptr_t new_pos = TokenPos();
@@ skipping 814 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart