always emit lazy field if overriding static

lib/src/compiler/code_generator.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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 638 matching lines @@
   void _registerPropertyOverrides(
       ClassElement classElem,
       JS.Expression className,
       List<ClassElement> superclasses,
       List<FieldDeclaration> fields,
       Map<FieldElement, JS.TemporaryId> virtualFields,
       List<JS.Statement> virtualFieldSymbols,
       Set<FieldElement> staticFieldOverrides) {
     for (var field in fields) {
       for (VariableDeclaration field in field.fields.variables) {
-        var overrideInfo = checkForPropertyOverride(
-            field.element, superclasses, _extensionTypes);
+        var overrideInfo =
+            checkForPropertyOverride(field.element, superclasses);
         if (overrideInfo.foundGetter || overrideInfo.foundSetter) {
           if (field.element.isStatic) {
             staticFieldOverrides.add(field.element);
           } else {
             var fieldName =
                 _emitMemberName(field.element.name, type: classElem.type);
             var virtualField = new JS.TemporaryId(field.element.name);
             virtualFields[field.element] = virtualField;
             virtualFieldSymbols.add(js.statement(
                 'const # = Symbol(#.name + "." + #.toString());',
@@ skipping 290 matching lines @@
 
   /// Emit a getter or setter that simply forwards to the superclass getter or
   /// setter. This is needed because in ES6, if you only override a getter
   /// (alternatively, a setter), then there is an implicit override of the
   /// setter (alternatively, the getter) that does nothing.
   JS.Method _emitSuperAccessorWrapper(MethodDeclaration method,
       InterfaceType type, List<ClassElement> superclasses) {
     var methodElement = method.element as PropertyAccessorElement;
     var field = methodElement.variable;
     if (!field.isSynthetic) return null;
-    var propertyOverrideResult = checkForPropertyOverride(
-        methodElement.variable, superclasses, _extensionTypes);
+    var propertyOverrideResult =
+        checkForPropertyOverride(methodElement.variable, superclasses);
 
     // Generate a corresponding virtual getter / setter.
     var name = _elementMemberName(methodElement,
         useExtension: _extensionTypes.isNativeClass(type.element));
     if (method.isGetter) {
       // Generate a setter
       if (field.setter != null || !propertyOverrideResult.foundSetter)
         return null;
       var fn = js.call('function(value) { super[#] = value; }', [name]);
       return new JS.Method(name, fn, isSetter: true);
@@ skipping 1964 matching lines @@
   JS.Statement _emitLazyFields(
       Element target, List<VariableDeclaration> fields) {
     var methods = [];
     for (var node in fields) {
       var name = node.name.name;
       var element = node.element;
       var access = _emitMemberName(name, isStatic: true);
       methods.add(annotate(
           new JS.Method(
               access,
-              js.call('function() { return #; }', _visit(node.initializer))
+              js.call('function() { return #; }', _visitInitializer(node))
               as JS.Fun,
               isGetter: true),
           node,
           _findAccessor(element, getter: true)));
 
       // TODO(jmesserly): currently uses a dummy setter to indicate writable.
       if (!node.isFinal && !node.isConst) {
         methods.add(annotate(
             new JS.Method(access, js.call('function(_) {}') as JS.Fun,
                 isSetter: true),
@@ skipping 1442 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';