Use correct type on evaluated literal symbols.

pkg/compiler/lib/src/js_backend/constant_system_javascript.dart

 // 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.
 
 library dart2js.constant_system.js;
 
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../constant_system_dart.dart';
@@ skipping 331 matching lines @@
     } else {
       type = new InterfaceType(classElement, typeArgument);
     }
     return new JavaScriptMapConstant(
         type, keysList, values, protoValue, onlyStringKeys);
   }
 
   @override
   ConstantValue createSymbol(Compiler compiler, String text) {
     // TODO(johnniwinther): Create a backend agnostic value.
-    InterfaceType type = compiler.coreTypes.symbolType;
+    JavaScriptBackend backend = compiler.backend;
+    ClassElement symbolClass = backend.helpers.symbolImplementationClass;
+    InterfaceType type = symbolClass.rawType;

[Siggi Cherem (dart-lang), 2016/05/26 19:52:15]

shouldn't symbolClass.rawType and coreTypes.symbolType be the same?

I guess symbolType comes from the unpatched Symbol, and symbolClass would be
Symbol.implementation? Should we anyways have an invariant in our system that
the type returned by a class element and it's implementation is the same
(cls.rawType == cls.implementation.rawType)?

[Johnni Winther, 2016/05/27 08:51:24]

It's worse. `coreTypes.symbolType` is the one defined in dart:core. The
`backend.helpers.symbolImplementationClass` is defined in dart:_internal. We
have

In dart:core :

class Symbol {
  external const factory Symbol(String name);
}

in core_patch.dart :

import 'dart:_internal' as internal;

@patch
class Symbol {
  @patch
  const factory Symbol(String name) = internal.Symbol;
}

and in dart:_internal :

import 'dart:core' as core;

class Symbol implements core.Symbol {
  final String name;

  const Symbol(String name);
}

[Siggi Cherem (dart-lang), 2016/05/27 17:27:08]

yikes - should we change the patch file to directly contain the implementation
instead?

[Johnni Winther, 2016/05/30 07:58:23]

I think we want to share the implementation between dart2js and VM (and
Dartino?). Don't know why; I guess Peter knows.

     ConstantValue argument = createString(new DartString.literal(text));
     Map<FieldElement, ConstantValue> fields = <FieldElement, ConstantValue>{};
-    JavaScriptBackend backend = compiler.backend;
-    backend.helpers.symbolImplementationClass.forEachInstanceField(
+    symbolClass.forEachInstanceField(
         (ClassElement enclosingClass, FieldElement field) {
       fields[field] = argument;
     });
     assert(fields.length == 1);
     return new ConstructedConstantValue(type, fields);
   }
 }
 
 class JavaScriptMapConstant extends MapConstantValue {
   /**
@@ skipping 30 matching lines @@
       result.add(keyList);
     } else {
       // Add the keys individually to avoid generating an unused list constant
       // for the keys.
       result.addAll(keys);
     }
     result.addAll(values);
     return result;
   }
 }