Implement symbol literals in the VM compiler

runtime/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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 9560 matching lines @@
     primary = ParseListLiteral(type_pos, is_const, type_arguments);
   } else if (CurrentToken() == Token::kLBRACE) {
     primary = ParseMapLiteral(type_pos, is_const, type_arguments);
   } else {
     ErrorMsg("unexpected token %s", Token::Str(CurrentToken()));
   }
   return primary;
 }
 
 
+AstNode* Parser::ParseSymbolLiteral() {
+  ASSERT(CurrentToken() == Token::kHASH);
+  ConsumeToken();
+  intptr_t symbol_pos = TokenPos();
+  String& symbol = String::Handle();
+  if (IsIdentifier()) {
+    symbol = CurrentLiteral()->raw();
+    ConsumeToken();
+    while (CurrentToken() == Token::kPERIOD) {
+      symbol = String::Concat(symbol, Symbols::Dot());
+      ConsumeToken();
+      symbol = String::Concat(symbol,
+                              *ExpectIdentifier("identifier expected"));
+    }
+  } else if (Token::CanBeOverloaded(CurrentToken())) {
+    symbol = String::New(Token::Str(CurrentToken()));
+    ConsumeToken();
+  } else {
+    ErrorMsg("illegal symbol literal");
+  }
+  // Lookup class Symbol from collection_dev library and call the
+  // constructor to create a symbol instance.
+  const Library& lib = Library::Handle(Library::CollectionDevLibrary());
+  const Class& symbol_class = Class::Handle(lib.LookupClass(Symbols::Symbol()));
+  ASSERT(!symbol_class.IsNull());
+  ArgumentListNode* constr_args = new ArgumentListNode(symbol_pos);
+  constr_args->Add(new LiteralNode(
+      symbol_pos, String::ZoneHandle(Symbols::New(symbol))));
+  const Function& constr = Function::ZoneHandle(
+      symbol_class.LookupConstructor(Symbols::SymbolCtor()));
+  ASSERT(!constr.IsNull());
+  const Object& result = Object::Handle(
+      EvaluateConstConstructorCall(symbol_class,
+                                   TypeArguments::Handle(),
+                                   constr,
+                                   constr_args));
+  if (result.IsUnhandledException()) {
+    return GenerateRethrow(symbol_pos, result);
+  }
+  const Instance& instance = Instance::Cast(result);
+  return new LiteralNode(symbol_pos, Instance::ZoneHandle(instance.raw()));
+}
+
+
 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.
   String& constructor_name =
       String::Handle(String::Concat(type_class_name, Symbols::Dot()));
   if (named_constructor != NULL) {
     constructor_name = String::Concat(constructor_name, *named_constructor);
@@ skipping 470 matching lines @@
       primary = ParseCompoundLiteral();
     } else {
       ConsumeToken();
       primary = ParseNewOperator(Token::kCONST);
     }
   } else if (CurrentToken() == Token::kLT ||
              CurrentToken() == Token::kLBRACK ||
              CurrentToken() == Token::kINDEX ||
              CurrentToken() == Token::kLBRACE) {
     primary = ParseCompoundLiteral();
+  } else if (CurrentToken() == Token::kHASH) {
+    primary = ParseSymbolLiteral();
   } else if (CurrentToken() == Token::kSUPER) {
     if (current_function().is_static()) {
       ErrorMsg("cannot access superclass from static method");
     }
     if (current_class().SuperClass() == Class::null()) {
       ErrorMsg("class '%s' does not have a superclass",
                String::Handle(current_class().Name()).ToCString());
     }
     if (current_class().IsMixinApplication()) {
       const Type& mixin_type = Type::Handle(current_class().mixin());
@@ skipping 361 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart