Allow variable minification in generative constructors.

sdk/lib/_internal/compiler/implementation/ssa/codegen.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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 55 matching lines @@
   CodeBuffer generateMethod(WorkItem work, HGraph graph) {
     return measure(() {
       compiler.tracer.traceGraph("codegen", graph);
       SsaOptimizedCodeGenerator codegen =
           new SsaOptimizedCodeGenerator(backend, work);
       codegen.visitGraph(graph);
 
       FunctionElement element = work.element;
       js.Block body;
       ClassElement enclosingClass = element.getEnclosingClass();
-      bool allowVariableMinification = !codegen.visitedForeignCode;
+      bool allowVariableMinification = !codegen.inhibitVariableMinification;
 
       if (element.isInstanceMember()
           && enclosingClass.isNative()
           && native.isOverriddenMethod(
               element, enclosingClass, nativeEmitter)) {
         // Record that this method is overridden. In case of optional
         // arguments, the emitter will generate stubs to handle them,
         // and needs to know if the method is overridden.
         nativeEmitter.overriddenMethods.add(element);
         StringBuffer buffer = new StringBuffer();
@@ skipping 69 matching lines @@
   static const int TYPE_STATEMENT = 0;
   static const int TYPE_EXPRESSION = 1;
   static const int TYPE_DECLARATION = 2;
 
   /**
    * Whether we are currently generating expressions instead of statements.
    * This includes declarations, which are generated as expressions.
    */
   bool isGeneratingExpression = false;
 
-  bool visitedForeignCode = false;
+  bool inhibitVariableMinification = false;
 
   final JavaScriptBackend backend;
   final WorkItem work;
   final HTypeMap types;
 
   final Set<HInstruction> generateAtUseSite;
   final Set<HInstruction> controlFlowOperators;
   final Map<Element, ElementAction> breakAction;
   final Map<Element, ElementAction> continueAction;
   final Map<Element, String> parameterNames;
@@ skipping 1594 matching lines @@
   visitLocalGet(HLocalGet node) {
     use(node.receiver);
   }
 
   visitLocalSet(HLocalSet node) {
     use(node.value);
     assignVariable(variableNames.getName(node.receiver), pop());
   }
 
   visitForeign(HForeign node) {
-    visitedForeignCode = true;
+    // TODO(sra): We could be a lot more picky about when to inhibit renaming of
+    // locals - most JS strings don't contain free variables, or contain safe
+    // ones like 'Object'.  JS strings like "#.length" and "#[#]" are perfectly
+    // safe for variable renaming.
+    inhibitVariableMinification = true;
     String code = node.code.slowToString();
     List<HInstruction> inputs = node.inputs;
     if (node.isJsStatement(types)) {
       if (!inputs.isEmpty) {
         compiler.internalError("foreign statement with inputs: $code",
                                instruction: node);
       }
       pushStatement(new js.LiteralStatement(code), node);
     } else {
       List<js.Expression> data = <js.Expression>[];
       for (int i = 0; i < inputs.length; i++) {
         use(inputs[i]);
         data.add(pop());
       }
       push(new js.LiteralExpression.withData(code, data), node);
     }
     DartType type = types[node].computeType(compiler);
     if (type != null) {
       world.registerInstantiatedClass(type.element);
     }
     // TODO(sra): Tell world.nativeEnqueuer about the types created here.
   }
 
   visitForeignNew(HForeignNew node) {
-    visitedForeignCode = true;
     String jsClassReference = backend.namer.isolateAccess(node.element);
     List<HInstruction> inputs = node.inputs;
     // We can't use 'visitArguments', since our arguments start at input[0].
     List<js.Expression> arguments = <js.Expression>[];
     for (int i = 0; i < inputs.length; i++) {
       use(inputs[i]);
       arguments.add(pop());
     }
     // TODO(floitsch): jsClassReference is an Access. We shouldn't treat it
     // as if it was a string.
@@ skipping 1239 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }