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

pkg/dev_compiler/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';
@@ skipping 81 matching lines @@
 
   /// In an async* function, this represents the stream controller parameter.
   JS.TemporaryId _asyncStarController;
 
   // TODO(jmesserly): fuse this with notNull check.
   final _privateNames =
       new HashMap<LibraryElement, HashMap<String, JS.TemporaryId>>();
   final _initializingFormalTemps =
       new HashMap<ParameterElement, JS.TemporaryId>();
 
+  final _syntheticSuperclasses = new HashMap<ClassElement, JS.Identifier>();
+
   JS.Identifier _extensionSymbolsModule;
   JS.Identifier _runtimeModule;
   final namedArgumentTemp = new JS.TemporaryId('opts');
 
   final _hasDeferredSupertype = new HashSet<ClassElement>();
 
   final _eagerTopLevelFields = new HashSet<Element>.identity();
 
   /// The  type provider from the current Analysis [context].
   final TypeProvider types;
@@ skipping 702 matching lines @@
     _classProperties = new ClassPropertyModel.build(classElem, extensions);
 
     var classExpr = _emitClassExpression(
         classElem, _emitClassMethods(node, ctors, fields),
         fields: allFields);
 
     var body = <JS.Statement>[];
     _initExtensionSymbols(classElem, methods, fields, body);
     _emitSuperHelperSymbols(_superHelperSymbols, body);
 
+    var syntheticSuperId = _syntheticSuperclasses[classElem];
+    if (syntheticSuperId != null) {
+      body.add(js.statement('const # = #;', [
+        syntheticSuperId,
+        _emitSyntheticSuperClassExpr(classElem, syntheticSuperId)
+      ]));
+    }
+
     // Emit the class, e.g. `core.Object = class Object { ... }`
     _defineClass(classElem, className, classExpr, isCallable, body);
 
     // Emit things that come after the ES6 `class ... { ... }`.
     var jsPeerNames = _getJSPeerNames(classElem);
+    var targetClassName = syntheticSuperId ?? className;
     JS.Statement deferredBaseClass =
-        _setBaseClass(classElem, className, jsPeerNames, body);
+        _setBaseClass(classElem, targetClassName, className, jsPeerNames, body);
 
     _emitClassTypeTests(classElem, className, body);
 
     _defineNamedConstructors(ctors, body, className, isCallableTransitive);
     _emitVirtualFieldSymbols(className, body);
+    _emitVirtualizedFieldSymbols(className, body);
     _emitClassSignature(
         methods, allFields, 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(
@@ skipping 244 matching lines @@
   }
 
   void _emitVirtualFieldSymbols(
       JS.Expression className, List<JS.Statement> body) {
     _classProperties.virtualFields.forEach((field, virtualField) {
       body.add(js.statement('const # = Symbol(#.name + "." + #.toString());',
           [virtualField, className, _declareMemberName(field.getter)]));
     });
   }
 
+  void _emitVirtualizedFieldSymbols(
+      JS.Expression className, List<JS.Statement> body) {
+    _classProperties.virtualizedFields.forEach((field, virtualField) {
+      body.add(js.statement('const # = #;', [
+        virtualField,
+        _callHelper('virtualName(#)', _declareMemberName(field.getter))
+      ]));
+    });
+  }
+
   void _defineClass(ClassElement classElem, JS.Expression className,
       JS.ClassExpression classExpr, bool isCallable, List<JS.Statement> body) {
     JS.Expression callableClass;
     if (isCallable && classElem.unnamedConstructor != null) {
       callableClass =
           _emitCallableClass(classExpr, classElem.unnamedConstructor);
     }
 
     if (classElem.typeParameters.isNotEmpty) {
       if (callableClass != null) {
@@ skipping 117 matching lines @@
     var genericInst = _emitType(dynType, lowerGeneric: true);
     return js.statement(
         '{ #; # = #; }', [genericDef, _emitTopLevelName(element), genericInst]);
   }
 
   bool _deferIfNeeded(DartType type, ClassElement current) {
     if (type is ParameterizedType) {
       var typeArguments = type.typeArguments;
       for (var typeArg in typeArguments) {
         var typeElement = typeArg.element;
-        // FIXME(vsm): This does not track mutual recursive dependences.
+        // FIXME(vsm): This does not track mutual recursive dependencies.
         if (current == typeElement || _deferIfNeeded(typeArg, current)) {
           return true;
         }
       }
     }
     return false;
   }
 
+  JS.Expression _emitSyntheticSuperClassExpr(
+      ClassElement element, JS.Identifier id) {
+    var heritage = _emitClassHeritage(element, ignoreSynthetic: true);
+    var typeParams = _emitTypeFormals(element.typeParameters);
+    var methods = <JS.Method>[];
+
+    // Introduce the new forwarder with one-shot initialization support.
+    var body = <JS.Statement>[];
+
+    var virtualizeArguments = <JS.Expression>[];
+    for (var field in _classProperties.virtualizedFields.keys) {
+      JS.TemporaryId fieldId = _classProperties.virtualizedFields[field];
+      var name = _declareMemberName(field.getter);
+      virtualizeArguments.add(name);
+      virtualizeArguments.add(fieldId);
+    }
+    body.add(_callHelperStatement(
+        'virtualize(this, #);', new JS.ArrayInitializer(virtualizeArguments)));
+    body.add(js.statement('super.new.apply(this, arguments)'));
+
+    var constructorName = _propertyName('new');
+    methods.add(new JS.Method(
+        constructorName, js.call('function() { #; }', [body]) as JS.Fun));
+
+    for (var field in _classProperties.virtualizedFields.keys) {
+      JS.TemporaryId fieldId = _classProperties.virtualizedFields[field];
+      var name = _declareMemberName(field.getter);
+      var getter = js.call('function() { return this[#]; }', [fieldId]);
+      methods.add(new JS.Method(name, getter, isGetter: true));
+      var setter = js.call('function(value) { this[#] = value; }', [fieldId]);
+      methods.add(new JS.Method(name, setter, isSetter: true));
+    }
+
+    return new JS.ClassExpression(id, heritage, methods,
+        typeParams: typeParams);
+  }
+
   JS.ClassExpression _emitClassExpression(
       ClassElement element, List<JS.Method> methods,
       {List<FieldDeclaration> fields}) {
     String name = element.name;
     var heritage = _emitClassHeritage(element);
     var typeParams = _emitTypeFormals(element.typeParameters);
     var jsFields = fields?.map(_emitTypeScriptField)?.toList();
 
     return new JS.ClassExpression(new JS.Identifier(name), heritage, methods,
         typeParams: typeParams, fields: jsFields);
   }
 
-  JS.Expression _emitClassHeritage(ClassElement element) {
+  JS.Expression _emitClassHeritage(ClassElement element,
+      {bool ignoreSynthetic = false}) {
     var type = element.type;
     if (type.isObject) return null;
 
     _loader.startTopLevel(element);
 
     // List of "direct" supertypes (supertype + mixins)
     var basetypes = [type.superclass]..addAll(type.mixins);
 
     // If any of these are recursive (via type parameter), defer setting
     // the real superclass.
     if (basetypes.any((t) => _deferIfNeeded(t, element))) {
       // Fall back to raw type
       basetypes =
           basetypes.map((t) => fillDynamicTypeArgs(t.element.type)).toList();
       _hasDeferredSupertype.add(element);
     }
 
     // List of "direct" JS superclasses
     var baseclasses = basetypes
         .map((t) => _emitConstructorAccess(t, nameType: false))
         .toList();
     assert(baseclasses.isNotEmpty);
+
+    if (!ignoreSynthetic &&
+        _classProperties != null &&
+        _classProperties.virtualizedFields.isNotEmpty) {
+      // TODO(kasperl): we would want to have a unique generated ID here.
+      // We can't use 'TemporaryId' since a class is "declared" twice:
+      //   var ClassName = class ClassName { ... }
+      var id = new JS.Identifier('${element.name}_${basetypes[0].name}');
+      _syntheticSuperclasses[element] = id;
+      baseclasses = [id];
+    }
+
     var heritage = (baseclasses.length == 1)
         ? baseclasses.first
         : _callHelper('mixin(#)', [baseclasses]);
 
     _loader.finishTopLevel(element);
 
     return heritage;
   }
 
   /// Provide Dart getters and setters that forward to the underlying native
@@ skipping 295 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) {
     var methodElement = method.element as PropertyAccessorElement;
     var field = methodElement.variable;
     if (!field.isSynthetic) return null;
+    if (!(field.getter?.isAbstract == false ||
+        field.setter?.isAbstract == false)) {
+      return null;
+    }
 
     // Generate a corresponding virtual getter / setter.
     var name = _declareMemberName(methodElement);
     if (method.isGetter) {
       var setter = field.setter;
       if ((setter == null || setter.isAbstract) &&
           _classProperties.inheritedSetters.contains(field.name)) {
         // Generate a setter that forwards to super.
         var fn = js.call('function(value) { super[#] = value; }', [name]);
         return new JS.Method(name, fn, isSetter: true);
@@ skipping 73 matching lines @@
       ClassElement classElem, String jsPeerName, List<JS.Statement> body) {
     if (jsPeerName != null) {
       body.add(_callHelperStatement('registerExtension(#.global.#, #);', [
         _runtimeModule,
         _propertyName(jsPeerName),
         _emitTopLevelName(classElem)
       ]));
     }
   }
 
-  JS.Statement _setBaseClass(ClassElement classElem, JS.Expression className,
-      List<String> jsPeerNames, List<JS.Statement> body) {
+  /// Sets the baseclass of [classElem], represented by [targetClassName], to
+  /// a "corrected" version of the base class.
+  ///
+  /// The [targetClassName] and [className] may differ if there is a
+  /// virtualization class injected in between the [classElem] and its
+  /// superclass.
+  JS.Statement _setBaseClass(
+      ClassElement classElem,
+      JS.Expression targetClassName,
+      JS.Expression className,
+      List<String> jsPeerNames,
+      List<JS.Statement> body) {
     var typeFormals = classElem.typeParameters;
     if (jsPeerNames.isNotEmpty && typeFormals.isNotEmpty) {
       for (var peer in jsPeerNames) {
         // TODO(jmesserly): we should just extend Array in the first place
         var newBaseClass = _callHelper('global.#', [peer]);
         body.add(_callHelperStatement(
-            'setExtensionBaseClass(#, #);', [className, newBaseClass]));
+            'setExtensionBaseClass(#, #);', [targetClassName, newBaseClass]));
       }
     } else if (_hasDeferredSupertype.contains(classElem)) {
       // TODO(vsm): consider just threading the deferred supertype through
       // instead of recording classElem in a set on the class and recomputing
       var newBaseClass = _emitType(classElem.type.superclass,
           nameType: false, subClass: classElem, className: className);
       if (classElem.type.mixins.isNotEmpty) {
         var mixins = classElem.type.mixins
             .map((t) => _emitType(t, nameType: false))
             .toList();
         mixins.insert(0, newBaseClass);
         newBaseClass = _callHelper('mixin(#)', [mixins]);
       }
       var deferredBaseClass = _callHelperStatement(
-          'setBaseClass(#, #);', [className, newBaseClass]);
+          'setBaseClass(#, #);', [targetClassName, newBaseClass]);
       if (typeFormals.isNotEmpty) return deferredBaseClass;
       body.add(deferredBaseClass);
     }
     return null;
   }
 
   void _defineNamedConstructors(List<ConstructorDeclaration> ctors,
       List<JS.Statement> body, JS.Expression className, bool isCallable) {
     var code = isCallable
         ? 'defineNamedConstructorCallable(#, #, #);'
@@ skipping 3250 matching lines @@
           js.call('(#[#._extensionType]) ? #[#[#]] : #.#',
               [l, _runtimeModule, l, _extensionSymbolsModule, name, l, name])
         ]);
       }
       return _callHelper('#(#, #)',
           [_emitDynamicOperationName('dload'), _visit(target), name]);
     }
 
     var jsTarget = _emitTarget(target, member, isStatic);
     bool isSuper = jsTarget is JS.Super;
-    if (isSuper &&
-        !member.isSynthetic &&
-        member is FieldElementImpl &&
-        !member.isVirtual) {
-      // If super.x is a sealed field, then x is an instance property since
-      // subclasses cannot override x.
-      jsTarget = new JS.This();
-    }
-
     JS.Expression result;
     if (member != null && member is MethodElement && !isStatic) {
       // Tear-off methods: explicitly bind it.
       if (isSuper) {
         result = _callHelper('bind(this, #, #.#)', [name, jsTarget, name]);
       } else if (_isObjectMemberCall(target, memberName)) {
         result = _callHelper('bind(#, #, #.#)',
             [jsTarget, _propertyName(memberName), _runtimeModule, memberName]);
       } else {
         result = _callHelper('bind(#, #)', [jsTarget, name]);
@@ skipping 888 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }