Change assert implementation to not depend on a top-level function called 'assert'.

lib/compiler/implementation/js_backend/emitter.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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 16 matching lines @@
  * in classes) are ignored, since they can be treated as non-class elements.
  *
  * The code for the containing (used) methods must exist in the [:universe:].
  */
 class CodeEmitterTask extends CompilerTask {
   bool needsInheritFunction = false;
   bool needsDefineClass = false;
   bool needsClosureClass = false;
   bool needsLazyInitializer = false;
   final Namer namer;
-  ConstantEmitter constantEmitter;
   NativeEmitter nativeEmitter;
   CodeBuffer boundClosureBuffer;
   CodeBuffer mainBuffer;
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
   final Map<int, String> boundClosureCache;
 
   final bool generateSourceMap;
 
-  CodeEmitterTask(Compiler compiler, Namer namer,
+  CodeEmitterTask(Compiler compiler, this.namer,
                   [bool generateSourceMap = false])
       : boundClosureBuffer = new CodeBuffer(),
         mainBuffer = new CodeBuffer(),
-        this.namer = namer,
         boundClosureCache = new Map<int, String>(),
         generateSourceMap = generateSourceMap,
-        constantEmitter = new ConstantEmitter(compiler, namer),
         super(compiler) {
     nativeEmitter = new NativeEmitter(this);
   }
 
-  void writeConstantToBuffer(Constant value, CodeBuffer buffer,
-                             [emitCanonicalVersion = true]) {
-    if (emitCanonicalVersion) {
-      constantEmitter.emitCanonicalVersionOfConstant(value, buffer);
-    } else {
-      constantEmitter.emitJavaScriptCodeForConstant(value, buffer);
-    }
-  }
-
   String get name => 'CodeEmitter';
 
   String get defineClassName
       => '${namer.ISOLATE}.\$defineClass';
   String get finishClassesName
       => '${namer.ISOLATE}.\$finishClasses';
   String get finishIsolateConstructorName
       => '${namer.ISOLATE}.\$finishIsolateConstructor';
   String get pendingClassesName
       => '${namer.ISOLATE}.\$pendingClasses';
@@ skipping 323 matching lines @@
         int index = names.indexOf(element.name);
         if (index != -1) {
           indexOfLastOptionalArgumentInParameters = count;
           // The order of the named arguments is not the same as the
           // one in the real method (which is in Dart source order).
           argumentsBuffer[count] = jsName;
           parametersBuffer[selector.positionalArgumentCount + index] = jsName;
         // Note that [elements] may be null for a synthetized [member].
         } else if (elements != null && elements.isParameterChecked(element)) {
           CodeBuffer argumentBuffer = new CodeBuffer();
-          writeConstantToBuffer(SentinelConstant.SENTINEL, argumentBuffer);
+          handler.writeConstant(argumentBuffer, SentinelConstant.SENTINEL);
           argumentsBuffer[count] = argumentBuffer.toString();
         } else {
           Constant value = handler.initialVariableValues[element];
           if (value == null) {
             argumentsBuffer[count] = NullConstant.JsNull;
           } else {
             if (!value.isNull()) {
               // If the value is the null constant, we should not pass it
               // down to the native method.
               indexOfLastOptionalArgumentInParameters = count;
             }
             CodeBuffer argumentBuffer = new CodeBuffer();
-            writeConstantToBuffer(value, argumentBuffer);
+            handler.writeConstant(argumentBuffer, value);
             argumentsBuffer[count] = argumentBuffer.toString();
           }
         }
       }
       count++;
     });
     String parametersString = Strings.join(parametersBuffer, ",");
     buffer.add('$parametersString) {\n');
 
     if (member.isNative()) {
@@ skipping 490 matching lines @@
     }
   }
 
   void emitStaticNonFinalFieldInitializations(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     List<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
     for (Element element in staticNonFinalFields) {
       buffer.add('$isolateProperties.${namer.getName(element)} = ');
       compiler.withCurrentElement(element, () {
-          Constant initialValue = handler.getInitialValueFor(element);
-          writeConstantToBuffer(initialValue, buffer);
+          handler.writeJsCodeForVariable(buffer, element);
         });
       buffer.add(';\n');
     }
   }
 
   void emitLazilyInitializedStaticFields(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     List<VariableElement> lazyFields =
         handler.getLazilyInitializedFieldsForEmission();
     if (!lazyFields.isEmpty()) {
@@ skipping 20 matching lines @@
         buffer.add(");\n");
       }
     }
   }
 
   void emitCompileTimeConstants(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     List<Constant> constants = handler.getConstantsForEmission();
     bool addedMakeConstantList = false;
     for (Constant constant in constants) {
-      // No need to emit functions. We already did that.
-      if (constant.isFunction()) continue;
-
-      String name = namer.constantName(constant);
+      String name = handler.getNameForConstant(constant);
       // The name is null when the constant is already a JS constant.
       // TODO(floitsch): every constant should be registered, so that we can
       // share the ones that take up too much space (like some strings).
       if (name === null) continue;
       if (!addedMakeConstantList && constant.isList()) {
         addedMakeConstantList = true;
         emitMakeConstantList(buffer);
       }
       buffer.add('$isolateProperties.$name = ');
-      writeConstantToBuffer(constant, buffer, emitCanonicalVersion: false);
+      handler.writeJsCode(buffer, constant);
       buffer.add(';\n');
     }
   }
 
   void emitMakeConstantList(CodeBuffer buffer) {
     buffer.add(namer.ISOLATE);
     buffer.add(@'''.makeConstantList = function(list) {
   list.immutable$list = true;
   list.fixed$length = true;
   return list;
@@ skipping 310 matching lines @@
         sourceName = token.slowToString();
       }
       sourceMapBuilder.addMapping(
           sourceFile, token.charOffset, sourceName, offset);
     });
     return sourceMapBuilder.build(compiledFile);
   }
 }
 
 typedef void DefineMemberFunction(String invocationName, CodeBuffer definition);