Emit forwarding getter/setter when overriding just a getter or setter.

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 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
+import 'package:analyzer/dart/ast/ast.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
-import 'package:analyzer/dart/ast/ast.dart' hide ConstantEvaluator;
-
-//TODO(leafp): Remove deprecated dependency
-//ignore: DEPRECATED_MEMBER_USE
+import 'package:analyzer/src/dart/ast/token.dart' show StringToken;
 import 'package:analyzer/src/generated/element.dart'
     show DynamicTypeImpl, LocalVariableElementImpl;
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/resolver.dart'
     show TypeProvider, NamespaceBuilder;
-import 'package:analyzer/src/dart/ast/token.dart' show StringToken;
 import 'package:analyzer/src/generated/type_system.dart'
     show StrongTypeSystemImpl;
 import 'package:analyzer/src/summary/summarize_elements.dart'
     show PackageBundleAssembler;
 import 'package:analyzer/src/task/strong/info.dart' show DynamicInvoke;
+import 'package:source_maps/source_maps.dart';
 
+import '../closure/closure_annotator.dart' show ClosureAnnotator;
 import '../js_ast/js_ast.dart' as JS;
 import '../js_ast/js_ast.dart' show js;
-import '../closure/closure_annotator.dart' show ClosureAnnotator;
-
 import 'ast_builder.dart' show AstBuilder;
 import 'compiler.dart'
     show BuildUnit, CompilerOptions, JSModuleFile, ModuleFormat;
 import 'element_helpers.dart';
 import 'element_loader.dart' show ElementLoader;
 import 'extension_types.dart' show ExtensionTypeSet;
-import 'js_field_storage.dart' show findFieldsNeedingStorage;
+import 'js_field_storage.dart' show checkForPropertyOverride, getSuperclasses;
 import 'js_interop.dart';
+import 'js_metalet.dart' as JS;
 import 'js_names.dart' as JS;
-import 'js_metalet.dart' as JS;
 import 'js_typeref_codegen.dart' show JsTypeRefCodegen;
 import 'module_builder.dart'
     show LegacyModuleBuilder, NodeModuleBuilder, pathToJSIdentifier;
 import 'nullable_type_inference.dart' show NullableTypeInference;
 import 'reify_coercions.dart' show CoercionReifier;
 import 'side_effect_analysis.dart' show ConstFieldVisitor, isStateless;
 import 'source_map_printer.dart' show SourceMapPrintingContext;
-import 'package:source_maps/source_maps.dart';
+//TODO(leafp): Remove deprecated dependency

[Jennifer Messerly, 2016/04/21 00:53:08]

it looks like this comment got moved around in a sort?

[Harry Terkelsen, 2016/04/21 01:00:11]

Done.

+//ignore: DEPRECATED_MEMBER_USE
+
 
 class CodeGenerator extends GeneralizingAstVisitor
     with ClosureAnnotator, JsTypeRefCodegen, NullableTypeInference {
   final AnalysisContext context;
   final CompilerOptions options;
   final rules = new StrongTypeSystemImpl();
 
   /// The set of libraries we are currently compiling, and the temporaries used
   /// to refer to them.
   ///
   /// We sometimes special case codegen for a single library, as it simplifies
   /// name scoping requirements.
   final _libraries = new Map<LibraryElement, JS.Identifier>();
 
   /// Imported libraries, and the temporaries used to refer to them.
   final _imports = new Map<LibraryElement, JS.TemporaryId>();
 
   /// The list of output module items, in the order they need to be emitted in.
   final _moduleItems = <JS.ModuleItem>[];
 
   /// The global extension type table.
   final ExtensionTypeSet _extensionTypes;
 
-  /// Information that is precomputed for this library, indicates which fields
-  /// need storage slots.
-  HashSet<FieldElement> _fieldsNeedingStorage;
-
   /// The variable for the target of the current `..` cascade expression.
   ///
   /// Usually a [SimpleIdentifier], but it can also be other expressions
   /// that are safe to evaluate multiple times, such as `this`.
   Expression _cascadeTarget;
 
   /// The variable for the current catch clause
   SimpleIdentifier _catchParameter;
 
   /// In an async* function, this represents the stream controller parameter.
@@ skipping 91 matching lines @@
     }
 
     return new Tuple2(printer.getText(), sourceMap?.build(unit.name + '.js'));
   }
 
   JS.Program _emitModule(List<CompilationUnit> compilationUnits) {
     if (_moduleItems.isNotEmpty) {
       throw new StateError('Can only call emitModule once.');
     }
 
-    _fieldsNeedingStorage = findFieldsNeedingStorage(
-        compilationUnits.map((u) => u.element), _extensionTypes);
-
     // Transform the AST to make coercions explicit.
     compilationUnits = CoercionReifier.reify(compilationUnits);
 
     // Initialize our library variables.
     var items = <JS.ModuleItem>[];
     for (var unit in compilationUnits) {
       var library = unit.element.library;
       if (unit.element != library.definingCompilationUnit) continue;
 
       var libraryTemp = _isDartRuntime(library)
@@ skipping 347 matching lines @@
     var body = <JS.Statement>[];
     var extensions = _extensionsToImplement(classElem);
     _initExtensionSymbols(classElem, methods, fields, body);
 
     // Emit the class, e.g. `core.Object = class Object { ... }`
     JS.Expression className = _defineClass(classElem, classExpr, body);
 
     // Emit things that come after the ES6 `class ... { ... }`.
     _setBaseClass(classElem, className, body);
     _defineNamedConstructors(ctors, body, className);
-    _emitVirtualFields(fields, className, body);
+    _emitVirtualFields(classElem, fields, className, body);
     _emitClassSignature(methods, classElem, ctors, extensions, className, body);
     _defineExtensionMembers(extensions, className, body);
     _emitClassMetadata(node.metadata, className, body);
 
     JS.Statement classDef = _statement(body);
     var typeFormals = classElem.typeParameters;
     if (typeFormals.isNotEmpty) {
       classDef = _defineClassTypeArguments(classElem, typeFormals, classDef);
     }
 
@@ skipping 199 matching lines @@
     var isObject = type.isObject;
 
     // Iff no constructor is specified for a class C, it implicitly has a
     // default constructor `C() : super() {}`, unless C is class Object.
     var jsMethods = <JS.Method>[];
     if (ctors.isEmpty && !isObject) {
       jsMethods.add(_emitImplicitConstructor(node, fields));
     }
 
     bool hasJsPeer = findAnnotation(element, isJsPeerInterface) != null;
+    var superclasses = getSuperclasses(element);
 
     bool hasIterator = false;
     for (var m in node.members) {
       if (m is ConstructorDeclaration) {
         jsMethods.add(_emitConstructor(m, type, fields, isObject));
       } else if (m is MethodDeclaration) {
         jsMethods.add(_emitMethodDeclaration(type, m));
 
+        if (m.element is PropertyAccessorElement) {
+          jsMethods.add(_emitSuperAccessorWrapper(m, type, superclasses));
+        }
+
         if (!hasJsPeer && m.isGetter && m.name.name == 'iterator') {
           hasIterator = true;
           jsMethods.add(_emitIterable(type));
         }
       } else if (m is FieldDeclaration && _extensionTypes.contains(element)) {
         jsMethods.addAll(_emitNativeFieldAccessors(m));
       }
     }
 
     // If the type doesn't have an `iterator`, but claims to implement Iterable,
     // we inject the adaptor method here, as it's less code size to put the
     // helper on a parent class. This pattern is common in the core libraries
     // (e.g. IterableMixin<E> and IterableBase<E>).
     //
     // (We could do this same optimization for any interface with an `iterator`
     // method, but that's more expensive to check for, so it doesn't seem worth
     // it. The above case for an explicit `iterator` method will catch those.)
     if (!hasJsPeer && !hasIterator && _implementsIterable(type)) {
       jsMethods.add(_emitIterable(type));
     }
 
     return jsMethods.where((m) => m != null).toList(growable: false);
   }
 
+  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);
+
+    // Generate a corresponding virtual getter / setter.
+    var name = _elementMemberName(methodElement,
+        allowExtensions: _extensionTypes.contains(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);
+    } else {
+      // Generate a getter
+      if (field.getter != null || !propertyOverrideResult.foundGetter)
+        return null;
+      var fn = js.call('function() { return super[#]; }', [name]);
+      return new JS.Method(name, fn, isGetter: true);
+    }
+  }
+
   bool _implementsIterable(InterfaceType t) =>
       t.interfaces.any((i) => i.element.type == types.iterableType);
 
   /// Support for adapting dart:core Iterable to ES6 versions.
   ///
   /// This lets them use for-of loops transparently:
   /// <https://github.com/lukehoban/es6features#iterators--forof>
   ///
   /// This will return `null` if the adapter was already added on a super type,
   /// otherwise it returns the adapter code.
@@ skipping 64 matching lines @@
       newBaseClass = _emitTypeName(classElem.type.superclass);
     }
     if (newBaseClass != null) {
       body.add(
           js.statement('dart.setBaseClass(#, #);', [className, newBaseClass]));
     }
   }
 
   /// Emits instance fields, if they are virtual
   /// (in other words, they override a getter/setter pair).
-  void _emitVirtualFields(List<FieldDeclaration> fields,
-      JS.Expression className, List<JS.Statement> body) {
+  void _emitVirtualFields(
+      ClassElement classElement,
+      List<FieldDeclaration> fields,
+      JS.Expression className,
+      List<JS.Statement> body) {
+    List<ClassElement> superclasses = getSuperclasses(classElement);
     for (FieldDeclaration member in fields) {
       for (VariableDeclaration field in member.fields.variables) {
-        if (_fieldsNeedingStorage.contains(field.element)) {
+        var propertyOverrideResult = checkForPropertyOverride(
+            field.element, superclasses, _extensionTypes);
+        if (!field.element.isSynthetic &&

[Jennifer Messerly, 2016/04/21 00:53:08]

I think these can't be synthetic, because we got them from the AST fields.
Perhaps make that an assert?

[Harry Terkelsen, 2016/04/21 01:00:11]

Done.

+            (propertyOverrideResult.foundGetter ||
+                propertyOverrideResult.foundSetter)) {
           body.add(_overrideField(className, field.element));
         }
       }
     }
   }
 
   void _defineNamedConstructors(List<ConstructorDeclaration> ctors,
       List<JS.Statement> body, JS.Expression className) {
     for (ConstructorDeclaration member in ctors) {
       if (member.name != null && member.factoryKeyword == null) {
@@ skipping 2849 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';