Handle symbol literals in closed_world2_test

tests/compiler/dart2js/mock_libraries.dart

 // Copyright (c) 2014, 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.
 
 // Library for creating mock versions of platform and internal libraries.
 
 library mock_libraries;
 
 const DEFAULT_PLATFORM_CONFIG = """
 [libraries]
 core:core/core.dart
 async:async/async.dart
 _js_helper:_internal/js_runtime/lib/js_helper.dart
 _interceptors:_internal/js_runtime/lib/interceptors.dart
+_internal:internal/internal.dart
 _isolate_helper:_internal/js_runtime/lib/isolate_helper.dart
 """;
 
 String buildLibrarySource(Map<String, String> elementMap,
     [Map<String, String> additionalElementMap = const <String, String>{}]) {
   Map<String, String> map = new Map<String, String>.from(elementMap);
   if (additionalElementMap != null) {
     map.addAll(additionalElementMap);
   }
   StringBuffer sb = new StringBuffer();
   map.values.forEach((String element) {
     sb.write('$element\n');
   });
   return sb.toString();
 }
 
 const Map<String, String> DEFAULT_CORE_LIBRARY = const <String, String>{
+  '<imports>': '''
+import 'dart:_internal' as internal;
+''',
   'bool': 'class bool {}',
   'Comparator': 'abstract class Comparator<T> {}',
   'DateTime': r'''
       class DateTime {
         DateTime(year);
         DateTime.utc(year);
       }''',
   'Deprecated': r'''
       class Deprecated extends Object {
         final String expires;
@@ skipping 49 matching lines @@
       class Object {
         const Object();
         operator ==(other) { return true; }
         get hashCode => throw "Object.hashCode not implemented.";
         String toString() { return null; }
         noSuchMethod(im) { throw im; }
       }''',
   'Resource': 'class Resource {}',
   'StackTrace': 'abstract class StackTrace {}',
   'String': 'class String implements Pattern {}',
-  'Symbol': 'class Symbol { final _name; const Symbol(this._name); }',
+  'Symbol': '''
+      abstract class Symbol { 
+        const factory Symbol(String name) = internal.Symbol; 
+      }
+      ''',
   'Type': 'class Type {}',
   'Pattern': 'abstract class Pattern {}',
   '_genericNoSuchMethod': '_genericNoSuchMethod(a,b,c,d,e) {}',
   '_unresolvedConstructorError': '_unresolvedConstructorError(a,b,c,d,e) {}',
   '_malformedTypeError': '_malformedTypeError(message) {}',
 };
 
+const Map<String, String> DEFAULT_INTERNAL_LIBRARY = const <String, String>{
+  '<imports>': '''
+import 'dart:core' as core;
+''',
+  'Symbol': '''
+class Symbol implements core.Symbol { 
+  final core.String _name; 
+  
+  const Symbol(this._name);
+  Symbol.validated(this._name);
+}
+''',
+};
+
 const String DEFAULT_PATCH_CORE_SOURCE = r'''
 import 'dart:_js_helper';
 import 'dart:_interceptors';
 import 'dart:_isolate_helper';
 import 'dart:async';
 
 @patch
 class LinkedHashMap<K, V> {
   factory LinkedHashMap._empty() => null;
   factory LinkedHashMap._literal(elements) => null;
@@ skipping 343 matching lines @@
 
     const LookupMap(this._entries, [this._nestedMaps = const []])
         : _key = null, _value = null;
 
     const LookupMap.pair(this._key, this._value)
         : _entries = const [], _nestedMaps = const [];
     V operator[](K k) => null;
   }''',
   '_version': 'const _version = "0.0.1+1";',
 };