use VariableElement instead of VariableElementImpl in _isStateless

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 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
@@ skipping 1679 matching lines @@
 
   /// True is the expression can be evaluated multiple times without causing
   /// code execution. This is true for final fields. This can be true for local
   /// variables, if:
   /// * they are not assigned within the [context].
   /// * they are not assigned in a function closure anywhere.
   bool _isStateless(Expression node, [AstNode context]) {
     if (node is SimpleIdentifier) {
       var e = node.staticElement;
       if (e is PropertyAccessorElement) e = e.variable;
-      if (e is VariableElementImpl && !e.isSynthetic) {
+      if (e is VariableElement && !e.isSynthetic) {

[Brian Wilkerson, 2015/04/04 15:58:24]

This is a good first step, but doesn't fix the problem. If 'e' is an instance of
ParameterMember it will pass this 'is' check, but will fail the 'is' check below
(line 1702).

We really need to address this issue in the Element API, but one ugly work
around would be to add the following before line 1702:
  // TODO Remove the following statement and convert the condition below to use
the public classes
  // once _isPotentiallyMutated does not require an implementation class.
  if (e is Member) {
    e = e.baseElement;
  }

[Jennifer Messerly, 2015/04/06 15:19:22]

Sounds good, but how can I get a ParameterMember here to test it? This code is
used when compiling a Dart method cascade, such as:

    x..add(1)..add(2)

How can I make "x" be a ParameterMember? I tried:

class Generic<T extends List<int>> {
  test_generic_type_parameter(T x) {
    x..add(1)..add(2)..add(3)..add(4);
  }
}

class Derived extends Generic<List<int>> {
  test_generic_type_parameter(List<int> x) {
    x..add(1)..add(2)..add(3)..add(4);
  }
}

Neither case was able to cause a problem.

[Brian Wilkerson, 2015/04/06 15:23:05]

I don't think you can. My comment was based on a misunderstanding on my part of
how this code was being used, and should be ignored. It's fine the way it is.

[Jennifer Messerly, 2015/04/06 15:46:31]

Ah that's good. I think I still like your variation `if (e is Member) e =
e.baseMember;` better as it seems cleaner and that way if someone later reused
this code, we'll be safer :). I'll also make the comment clear that this
function (_isStateless) is intended to be conservative, and should not be relied
on to correctly detect all cases.

         if (e.isFinal) return true;
         if (e is LocalVariableElementImpl || e is ParameterElementImpl) {
           // make sure the local isn't mutated in the context.
           return !_isPotentiallyMutated(e, context);
         }
       }
     }
     return false;
   }
 
@@ skipping 650 matching lines @@
 
     // TODO(jmesserly): in many cases marking the end will be unncessary.
     printer.mark(_location(node.end));
   }
 
   String _getIdentifier(AstNode node) {
     if (node is SimpleIdentifier) return node.name;
     return null;
   }
 }