fix temps that have the same name to have different Elements

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;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 1154 matching lines @@
     // initializing formal parameter, e.g. `Point(this.x)`
     if (element is ParameterElement &&
         element.isInitializingFormal &&
         element.isPrivate) {
       /// Rename private names so they don't shadow the private field symbol.
       /// The renamer would handle this, but it would prefer to rename the
       /// temporary used for the private symbol. Instead rename the parameter.
       return _getTemp(element, '${name.substring(1)}');
     }
 
-    if (_isTemporary(element)) {
+    if (element is TemporaryVariableElement) {
       if (name[0] == '#') {
         return new JS.InterpolatedExpression(name.substring(1));
       } else {
         return _getTemp(element, name);
       }
     }
 
     return new JS.Identifier(name);
   }
 
@@ skipping 582 matching lines @@
   SimpleIdentifier _createTemporary(String name, DartType type) {
     // We use an invalid source location to signal that this is a temporary.
     // See [_isTemporary].
     // TODO(jmesserly): alternatives are
     // * (ab)use Element.isSynthetic, which isn't currently used for
     //   LocalVariableElementImpl, so we could repurpose to mean "temp".
     // * add a new property to LocalVariableElementImpl.
     // * create a new subtype of LocalVariableElementImpl to mark a temp.
     var id =
         new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, name, -1));
-    id.staticElement = new LocalVariableElementImpl.forNode(id);
+    id.staticElement = new TemporaryVariableElement.forNode(id);
     id.staticType = type;
     return id;
   }
 
   JS.Expression _const(Expression node, JS.Expression expr, [String nameHint]) {
     var value = js.call('dart.const(#)', expr);
 
     // If we're inside a method or function, capture the value into a
     // global temporary, so we don't do the expensive canonicalization step.
     var ancestor = node.getAncestor((n) => n is FunctionBody ||
         (n is FieldDeclaration && n.staticKeyword == null));
     if (ancestor == null) return value;
 
     if (nameHint == null) {
       nameHint = 'const_' + getStaticType(node).name;
     }
 
     // TODO(jmesserly): enable this once we fix
     // https://github.com/dart-lang/dev_compiler/issues/131
     /*var temp = new JSTemporary(nameHint);
     _pendingStatements.add(js.statement('let # = #;', [temp, value]));
     return temp;*/
     assert(nameHint != null); // so it's not marked unused
     return value;
   }
 
-  bool _isTemporary(Element node) => node.nameOffset == -1;
-
   /// Returns a new expression, which can be be used safely *once* on the
   /// left hand side, and *once* on the right side of an assignment.
   /// For example: `expr1[expr2] += y` can be compiled as
   /// `expr1[expr2] = expr1[expr2] + y`.
   ///
   /// The temporary scope will ensure `expr1` and `expr2` are only evaluated
   /// once: `((x1, x2) => x1[x2] = x1[x2] + y)(expr1, expr2)`.
   ///
   /// If the expression does not end up using `x1` or `x2` more than once, or
   /// if those expressions can be treated as stateless (e.g. they are
@@ skipping 795 matching lines @@
 // TODO(jmesserly): validate the library. See issue #135.
 bool _isJsNameAnnotation(DartObjectImpl value) => value.type.name == 'JsName';
 
 bool _isJsPeerInterface(DartObjectImpl value) =>
     value.type.name == 'JsPeerInterface';
 
 // TODO(jacobr): we would like to do something like the following
 // but we don't have summary support yet.
 // bool _supportJsExtensionMethod(AnnotatedNode node) =>
 //    _getAnnotation(node, "SupportJsExtensionMethod") != null;
+
+/// 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);
+}