Support virtual fields in DDC without requiring the @virtual annotation.

pkg/dev_compiler/lib/src/compiler/class_property_model.dart

 // Copyright (c) 2016, 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 HashSet;
+import 'dart:collection' show HashMap, HashSet;
 
+import 'package:analyzer/analyzer.dart' as analyzer;
 import 'package:analyzer/dart/ast/ast.dart' show Identifier;
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/element.dart' show FieldElementImpl;
 
 import '../js_ast/js_ast.dart' as JS;
 import 'element_helpers.dart';
 import 'js_names.dart' as JS;
 
 /// Tracks how fields, getters and setters are represented when emitting JS.
 ///
 /// Dart classes have implicit features that must be made explicit:
 ///
 /// - virtual fields induce a getter and setter pair.
 /// - getters and setters are independent.
 /// - getters and setters can be overridden.
 ///
 class ClassPropertyModel {
   /// Fields that are virtual, that is, they must be generated as a property
   /// pair in JavaScript.
   ///
   /// The value property stores the symbol used for the field's storage slot.
   final virtualFields = <FieldElement, JS.TemporaryId>{};
 
+  /// Fields that have been overridden by the current class and must be
+  /// virtualized.
+  ///
+  /// These fields are the elements of the super class, and not the
+  /// overriding elements.
+  ///
+  /// These elements must point to real fields (not getters).
+  final virtualizedFields = <FieldElement, JS.TemporaryId>{};
+
   /// Static fields that are overridden, this does not matter for Dart but in
   /// JS we need to take care initializing these because JS classes inherit
   /// statics.
   final staticFieldOverrides = new HashSet<FieldElement>();
 
   /// The set of inherited getters, used because JS getters/setters are paired,
   /// so if we're generating a setter we may need to emit a getter that calls
   /// super.
   final inheritedGetters = new HashSet<String>();
 
   /// The set of inherited setters, used because JS getters/setters are paired,
   /// so if we're generating a getter we may need to emit a setter that calls
   /// super.
   final inheritedSetters = new HashSet<String>();
 
   ClassPropertyModel.build(
       ClassElement classElem, Iterable<ExecutableElement> extensionMembers) {
+    LibraryElement classLibrary = classElem.library;
+    HashMap<String, FieldElementImpl> overriddenFields = new HashMap();
+    HashSet<String> alreadyVirtual = new HashSet();
+
     // Visit superclasses to collect information about their fields/accessors.
     // This is expensive so we try to collect everything in one pass.
     for (var base in getSuperclasses(classElem)) {
       for (var accessor in base.accessors) {
         // For getter/setter pairs only process them once.
         if (accessor.correspondingGetter != null) continue;
 
         var field = accessor.variable;
         var name = field.name;
+
         // Ignore private names from other libraries.
         if (Identifier.isPrivateName(name) &&
-            accessor.library != classElem.library) {
+            accessor.library != classLibrary) {
           continue;
         }
 
-        if (field.getter?.isAbstract == false) inheritedGetters.add(name);
-        if (field.setter?.isAbstract == false) inheritedSetters.add(name);
+        // Ignore abstract getters and setters.
+        if (!(field.getter?.isAbstract == false ||
+            field.setter?.isAbstract == false)) {
+          continue;
+        }
+
+        if (!field.isStatic && !alreadyVirtual.contains(name)) {
+          // Synthetic field means there is a getter or setter and the member
+          // is therefore already virtual.
+          if (field.isSynthetic) {
+            alreadyVirtual.add(name);
+          } else if (field is FieldElementImpl) {
+            if (overriddenFields.containsKey(name)) {
+              // The field is already overridden by a super class.
+              // class A { int x; }  // Second time the field is added.
+              // class B extends A { int x; }  // First time the field is added.
+              // class C extends B { ... };
+              alreadyVirtual.add(name);
+            } else {
+              overriddenFields[name] = field;
+            }
+          }
+        }
+
+        if (field.getter?.isAbstract == false) {
+          inheritedGetters.add(name);
+        }
+        if (field.setter?.isAbstract == false) {
+          inheritedSetters.add(name);
+        }
       }
     }
 
     var extensionNames =
         new HashSet<String>.from(extensionMembers.map((e) => e.name));
 
     // Visit accessors in the current class, and see if they need to be
     // generated differently based on the inherited fields/accessors.
     for (var accessor in classElem.accessors) {
       // For getter/setter pairs only process them once.
       if (accessor.correspondingGetter != null) continue;
       // Also ignore abstract fields.
       if (accessor.isAbstract) continue;
 
       var field = accessor.variable;
       var name = field.name;
+
+      if (!field.isStatic &&
+          !alreadyVirtual.contains(name) &&
+          overriddenFields.containsKey(name)) {
+        JS.TemporaryId id = new JS.TemporaryId(name);
+        var superField = overriddenFields[name];
+        virtualizedFields[superField] = id;
+        alreadyVirtual.add(name);
+      }
+
       // Is it a field?
       if (!field.isSynthetic && field is FieldElementImpl) {
         if (inheritedGetters.contains(name) ||
             inheritedSetters.contains(name) ||
-            extensionNames.contains(name) ||
-            field.isVirtual) {
+            extensionNames.contains(name)) {
           if (field.isStatic) {
             staticFieldOverrides.add(field);
           } else {
             virtualFields[field] = new JS.TemporaryId(name);
           }
         }
       }
     }
+
+    // Run through all bodies and find all `super.x` accesses. Then take their
+    // names (`x`) and see if they need to be virtualized.
+    for (var name in SuperFinder.accessedSuperProperties(classElem)) {
+      if (!alreadyVirtual.contains(name) &&
+          overriddenFields.containsKey(name)) {
+        JS.TemporaryId id = new JS.TemporaryId(name);
+        var superField = overriddenFields[name];
+        virtualizedFields[superField] = id;
+      }
+    }
   }
 }
+
+class SuperFinder extends analyzer.GeneralizingAstVisitor<Object> {
+  final accessed = new HashSet<String>();
+
+  static Iterable<String> accessedSuperProperties(ClassElement element) {
+    // When compiling the SDK, only one out of ~50 classes has any references to
+    // super at all, so we avoid searching the method bodies in the common case.
+    if (!element.hasReferenceToSuper) return const <String>[];
+    SuperFinder finder = new SuperFinder();
+    element.computeNode().accept(finder);
+    return finder.accessed;
+  }
+
+  @override
+  analyzer.PropertyAccess visitPropertyAccess(analyzer.PropertyAccess node) {
+    if (node.realTarget is analyzer.SuperExpression) {
+      var name = node.propertyName.name;
+      accessed.add(name);
+    }
+    return node;
+  }
+}