dart2js: Support const symbols in the startup emitter.

pkg/compiler/lib/src/js_emitter/program_builder/program_builder.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 dart2js.js_emitter.program_builder;
 
 import '../js_emitter.dart' show computeMixinClass, Emitter;
 import '../model.dart';
 
 import '../../common.dart';
@@ skipping 64 matching lines @@
   final Map<ClassElement, Class> _classes = <ClassElement, Class>{};
 
   /// Mapping from [OutputUnit] to constructed [Fragment]. We need this to
   /// generate the deferredLoadingMap (to know which hunks to load).
   final Map<OutputUnit, Fragment> _outputs = <OutputUnit, Fragment>{};
 
   /// Mapping from [ConstantValue] to constructed [Constant]. We need this to
   /// update field-initializers to point to the ConstantModel.
   final Map<ConstantValue, Constant> _constants = <ConstantValue, Constant>{};
 
+  /// Mapping from names to strings.
+  ///
+  /// This mapping is used to support `const Symbol` expressions.
+  ///
+  /// This map is filled when building classes.
+  final Map<js.Name, String> _symbolsMap = <js.Name, String>{};
+
   Set<Class> _unneededNativeClasses;
 
   Program buildProgram({bool storeFunctionTypesInMetadata: false}) {
     collector.collect();
 
     this._storeFunctionTypesInMetadata = storeFunctionTypesInMetadata;
     // Note: In rare cases (mostly tests) output units can be empty. This
     // happens when the deferred code is dead-code eliminated but we still need
     // to check that the library has been loaded.
     _compiler.deferredLoadTask.allOutputUnits.forEach(
@@ skipping 60 matching lines @@
     List<js.TokenFinalizer> finalizers = [_task.metadataCollector];
     if (backend.namer is js.TokenFinalizer) {
       var namingFinalizer = backend.namer;
       finalizers.add(namingFinalizer);
     }
 
     return new Program(
         fragments,
         holders,
         _buildLoadMap(),
+        _symbolsMap,
         _buildTypeToInterceptorMap(),
         _task.metadataCollector,
         finalizers,
         needsNativeSupport: needsNativeSupport,
         outputContainsConstantList: collector.outputContainsConstantList,
         hasIsolateSupport: _compiler.hasIsolateSupport);
   }
 
   void _markEagerClasses() {
     _markEagerInterceptorClasses();
@@ skipping 212 matching lines @@
             callStubs.add(_buildStubMethod(name, code, element: member));
           });
         }
       }
     }
 
     List<StubMethod> typeVariableReaderStubs =
         runtimeTypeGenerator.generateTypeVariableReaderStubs(element);
 
     List<StubMethod> noSuchMethodStubs = <StubMethod>[];
+
     if (backend.enabledNoSuchMethod && element == _compiler.objectClass) {
       Map<js.Name, Selector> selectors =
           classStubGenerator.computeSelectorsForNsmHandlers();
       selectors.forEach((js.Name name, Selector selector) {
+        // If the program contains `const Symbol` names we have to retain them.
+        String selectorName = selector.name;
+        if (selector.isSetter) selectorName = "$selectorName=";
+        if (backend.symbolsUsed.contains(selectorName)) {
+          _symbolsMap[name] = selectorName;
+        }
         noSuchMethodStubs
             .add(classStubGenerator.generateStubForNoSuchMethod(name,
                                                                 selector));
       });
     }
 
     if (element == backend.closureClass) {
       // We add a special getter here to allow for tearing off a closure from
       // itself.
       js.Name name = namer.getterForMember(Selector.CALL_NAME);
@@ skipping 403 matching lines @@
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 
   Holder _registerStaticStateHolder() {
     return _registry.registerHolder(
         namer.staticStateHolder, isStaticStateHolder: true);
   }
 }