fix implicit_scope_test and builtin_identifier_test

lib/src/codegen/js_codegen.dart

 // Copyright (c) 2015, 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 dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 1756 matching lines @@
   @override
   JS.Block visitBlockFunctionBody(BlockFunctionBody node) {
     var initArgs = _emitArgumentInitializers(node.parent);
     var block = visitBlock(node.block);
     if (initArgs != null) return new JS.Block([initArgs, block]);
     return block;
   }
 
   @override
   JS.Block visitBlock(Block node) =>
-      new JS.Block(_visitList(node.statements) as List<JS.Statement>);
+      new JS.Block(_visitList(node.statements) as List<JS.Statement>,
+          isScope: true);
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     if (node.operator != null && node.operator.lexeme == '?.') {
       return _emitNullSafe(node);
     }
 
     var target = _getTarget(node);
     var result = _emitForeignJS(node);
     if (result != null) return result;
@@ skipping 938 matching lines @@
 
   @override
   visitRethrowExpression(RethrowExpression node) {
     if (node.parent is ExpressionStatement) {
       return js.statement('throw #;', _visit(_catchParameter));
     } else {
       return js.call('throw #', _visit(_catchParameter));
     }
   }
 
+  /// Visits a statement, and ensures the resulting AST handles block scope
+  /// correctly. Essentially, we need to promote a variable declaration
+  /// statement into a block in some cases, e.g.
+  ///
+  ///     do var x = 5; while (false); // Dart
+  ///     do { let x = 5; } while (false); // JS
+  JS.Statement _visitScope(Statement stmt) {
+    var result = _visit(stmt);
+    if (result is JS.ExpressionStatement &&
+        result.expression is JS.VariableDeclarationList) {
+      return new JS.Block([result]);
+    }
+    return result;
+  }
+
   @override
   JS.If visitIfStatement(IfStatement node) {
-    return new JS.If(notNull(node.condition), _visit(node.thenStatement),
-        _visit(node.elseStatement));
+    return new JS.If(notNull(node.condition), _visitScope(node.thenStatement),
+        _visitScope(node.elseStatement));
   }
 
   @override
   JS.For visitForStatement(ForStatement node) {
     var init = _visit(node.initialization);
     if (init == null) init = _visit(node.variables);
     var update = _visitListToBinary(node.updaters, ',');
     if (update != null) update = update.toVoidExpression();
-    return new JS.For(init, notNull(node.condition), update, _visit(node.body));
+    return new JS.For(
+        init, notNull(node.condition), update, _visitScope(node.body));
   }
 
   @override
   JS.While visitWhileStatement(WhileStatement node) {
-    return new JS.While(notNull(node.condition), _visit(node.body));
+    return new JS.While(notNull(node.condition), _visitScope(node.body));
   }
 
   @override
   JS.Do visitDoStatement(DoStatement node) {
-    return new JS.Do(_visit(node.body), notNull(node.condition));
+    return new JS.Do(_visitScope(node.body), notNull(node.condition));
   }
 
   @override
   JS.Statement visitForEachStatement(ForEachStatement node) {
     if (node.awaitKeyword != null) {
       return _emitAwaitFor(node);
     }
 
     var init = _visit(node.identifier);
     if (init == null) {
       init = js.call('let #', node.loopVariable.identifier.name);
     }
-    return new JS.ForOf(init, _visit(node.iterable), _visit(node.body));
+    return new JS.ForOf(init, _visit(node.iterable), _visitScope(node.body));
   }
 
   JS.Statement _emitAwaitFor(ForEachStatement node) {
     // Emits `await for (var value in stream) ...`, which desugars as:
     //
     // var iter = new StreamIterator<T>(stream);
     // try {
     //   while (await iter.moveNext()) {
     //     var value = iter.current;
     //     ...
@@ skipping 509 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }