fixes #27385, implement virtual fields in DDC

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';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/ast/token.dart' show StringToken;
 import 'package:analyzer/src/dart/element/element.dart'
-    show LocalVariableElementImpl;
+    show FieldElementImpl, LocalVariableElementImpl;
 import 'package:analyzer/src/dart/element/type.dart' show DynamicTypeImpl;
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/resolver.dart'
     show TypeProvider, NamespaceBuilder;
 import 'package:analyzer/src/generated/type_system.dart'
     show StrongTypeSystemImpl;
 import 'package:analyzer/src/summary/idl.dart' show UnlinkedUnit;
 import 'package:analyzer/src/summary/link.dart' as summary_link;
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/summary/summarize_ast.dart'
     show serializeAstUnlinked;
 import 'package:analyzer/src/summary/summarize_elements.dart'
     show PackageBundleAssembler;
 import 'package:analyzer/src/summary/summary_sdk.dart';
 import 'package:analyzer/src/task/strong/ast_properties.dart'
     show isDynamicInvoke, setIsDynamicInvoke, getImplicitAssignmentCast;
 import 'package:path/path.dart' show separator;
 
 import '../closure/closure_annotator.dart' show ClosureAnnotator;
 import '../js_ast/js_ast.dart' as JS;
 import '../js_ast/js_ast.dart' show js;
 import 'ast_builder.dart' show AstBuilder;
+import 'class_property_model.dart';
 import 'compiler.dart' show BuildUnit, CompilerOptions, JSModuleFile;
 import 'element_helpers.dart';
 import 'element_loader.dart' show ElementLoader;
 import 'extension_types.dart' show ExtensionTypeSet;
-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_typeref_codegen.dart' show JsTypeRefCodegen;
 import 'module_builder.dart' show pathToJSIdentifier;
 import 'nullable_type_inference.dart' show NullableTypeInference;
 import 'reify_coercions.dart' show CoercionReifier;
 import 'side_effect_analysis.dart' show ConstFieldVisitor, isStateless;
 import 'type_utilities.dart';
 
@@ skipping 87 matching lines @@
   bool _superAllowed = true;
 
   List<JS.TemporaryId> _superHelperSymbols = <JS.TemporaryId>[];
   List<JS.Method> _superHelpers = <JS.Method>[];
 
   List<TypeParameterType> _typeParamInConst = null;
 
   /// Whether we are currently generating code for the body of a `JS()` call.
   bool _isInForeignJS = false;
 
+  /// Information about virtual and overridden fields/getters/setters in the
+  /// class we're currently compiling, or `null` if we aren't compiling a class.
+  ClassPropertyModel _classProperties;
+
   CodeGenerator(
       AnalysisContext c, this.summaryData, this.options, this._extensionTypes)
       : context = c,
         types = c.typeProvider,
         _asyncStreamIterator =
             _getLibrary(c, 'dart:async').getType('StreamIterator').type,
         _jsArray = _getLibrary(c, 'dart:_interceptors').getType('JSArray'),
         interceptorClass =
             _getLibrary(c, 'dart:_interceptors').getType('Interceptor'),
         dartCoreLibrary = _getLibrary(c, 'dart:core'),
@@ skipping 577 matching lines @@
     var classElem = resolutionMap.elementDeclaredByClassDeclaration(node);
 
     // If this class is annotated with `@JS`, then there is nothing to emit.
     if (findAnnotation(classElem, isPublicJSAnnotation) != null) return null;
 
     // If this is a JavaScript type, emit it now and then exit.
     var jsTypeDef = _emitJsType(classElem);
     if (jsTypeDef != null) return jsTypeDef;
 
     var ctors = <ConstructorDeclaration>[];
+    var allFields = <FieldDeclaration>[];
     var fields = <FieldDeclaration>[];
     var staticFields = <FieldDeclaration>[];
     var methods = <MethodDeclaration>[];
 
     // True if a "call" method or getter exists directly on this class.
     // If so, we need to install a Function prototype.
     bool isCallable = false;
     for (var member in node.members) {
       if (member is ConstructorDeclaration) {
         ctors.add(member);
       } else if (member is FieldDeclaration) {
+        allFields.add(member);
         (member.isStatic ? staticFields : fields).add(member);
       } else if (member is MethodDeclaration) {
         methods.add(member);
         if (member.name.name == 'call' && !member.isSetter) {
           //
           // Make sure "call" has a statically known function type:
           //
           // - if it's a method, then it does because all methods do,
           // - if it's a getter, check the return type.
           //
@@ skipping 21 matching lines @@
 
     JS.Expression className;
     if (classElem.typeParameters.isNotEmpty) {
       // Generic classes will be defined inside a function that closes over the
       // type parameter. So we can use their local variable name directly.
       className = new JS.Identifier(classElem.name);
     } else {
       className = _emitTopLevelName(classElem);
     }
 
-    var allFields = fields.toList()..addAll(staticFields);
-    var superclasses = getSuperclasses(classElem);
-    var virtualFields = <FieldElement, JS.TemporaryId>{};
-    var virtualFieldSymbols = <JS.Statement>[];
-    var staticFieldOverrides = new HashSet<FieldElement>();
     var extensions = _extensionsToImplement(classElem);
-    _registerPropertyOverrides(classElem, className, superclasses, allFields,
-        virtualFields, virtualFieldSymbols, staticFieldOverrides, extensions);
+    var savedClassProperties = _classProperties;
+    _classProperties = new ClassPropertyModel.build(classElem, extensions);
 
-    var classExpr = _emitClassExpression(classElem,
-        _emitClassMethods(node, ctors, fields, superclasses, virtualFields),
+    var classExpr = _emitClassExpression(
+        classElem, _emitClassMethods(node, ctors, fields),
         fields: allFields);
 
     var body = <JS.Statement>[];
     _initExtensionSymbols(classElem, methods, fields, body);
     _emitSuperHelperSymbols(_superHelperSymbols, body);
 
     // 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);
     JS.Statement deferredBaseClass =
         _setBaseClass(classElem, className, jsPeerNames, body);
 
     _emitClassTypeTests(classElem, className, body);
 
     _defineNamedConstructors(ctors, body, className, isCallableTransitive);
-    body.addAll(virtualFieldSymbols);
+    _emitVirtualFieldSymbols(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(
           classElem, typeFormals, classDef, className, deferredBaseClass);
     }
 
     body = <JS.Statement>[classDef];
-    _emitStaticFields(staticFields, staticFieldOverrides, classElem, body);
+    _emitStaticFields(staticFields, classElem, body);
     for (var peer in jsPeerNames) {
       _registerExtensionType(classElem, peer, body);
     }
+
+    _classProperties = savedClassProperties;
     return _statement(body);
   }
 
   /// Emits code to support a class with a "call" method and an unnamed
   /// constructor.
   ///
   /// This ensures instances created by the unnamed constructor are functions.
   /// Named constructors are handled elsewhere, see [_defineNamedConstructors].
   JS.Expression _emitCallableClass(
       JS.ClassExpression classExpr, ConstructorElement unnamedCtor) {
@@ skipping 197 matching lines @@
   }
 
   void _emitSuperHelperSymbols(
       List<JS.TemporaryId> superHelperSymbols, List<JS.Statement> body) {
     for (var id in superHelperSymbols) {
       body.add(js.statement('const # = Symbol(#)', [id, js.string(id.name)]));
     }
     superHelperSymbols.clear();
   }
 
-  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,
-      Iterable<ExecutableElement> extensionMembers) {
-    var extensionNames =
-        new HashSet<String>.from(extensionMembers.map((e) => e.name));
-    for (var field in fields) {
-      for (VariableDeclaration fieldDecl in field.fields.variables) {
-        var field = fieldDecl.element as FieldElement;
-        var overrideInfo = checkForPropertyOverride(field, superclasses);
-        if (overrideInfo.foundGetter ||
-            overrideInfo.foundSetter ||
-            extensionNames.contains(field.name)) {
-          if (field.isStatic) {
-            staticFieldOverrides.add(field);
-          } else {
-            var virtualField = new JS.TemporaryId(field.name);
-            virtualFields[field] = virtualField;
-            virtualFieldSymbols.add(js.statement(
-                'const # = Symbol(#.name + "." + #.toString());',
-                [virtualField, className, _declareMemberName(field.getter)]));
-          }
-        }
-      }
-    }
+  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 _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);
     }
 
@@ skipping 191 matching lines @@
               [value], js.statement('{ this.# = #; }', [name, value]));
           method = new JS.Method(_declareMemberName(field.setter), fn,
               isSetter: true);
           jsMethods.add(method);
         }
       }
     }
     return jsMethods;
   }
 
-  List<JS.Method> _emitClassMethods(
-      ClassDeclaration node,
-      List<ConstructorDeclaration> ctors,
-      List<FieldDeclaration> fields,
-      List<ClassElement> superclasses,
-      Map<FieldElement, JS.TemporaryId> virtualFields) {
+  List<JS.Method> _emitClassMethods(ClassDeclaration node,
+      List<ConstructorDeclaration> ctors, List<FieldDeclaration> fields) {
     var element = resolutionMap.elementDeclaredByClassDeclaration(node);
     var type = element.type;
     var isObject = type.isObject;
+    var virtualFields = _classProperties.virtualFields;
 
     // 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 (isObject) {
       // Implements Dart constructor behavior.
       //
       // Because of ES6 constructor restrictions (`this` is not available until
       // `super` is called), we cannot emit an actual ES6 `constructor` on our
       // classes and preserve the Dart initialization order.
@@ skipping 20 matching lines @@
 
     bool hasIterator = false;
     for (var m in node.members) {
       if (m is ConstructorDeclaration) {
         jsMethods
             .add(_emitConstructor(m, type, fields, virtualFields, isObject));
       } else if (m is MethodDeclaration) {
         jsMethods.add(_emitMethodDeclaration(type, m));
 
         if (m.element is PropertyAccessorElement) {
-          jsMethods.add(_emitSuperAccessorWrapper(m, type, superclasses));
+          jsMethods.add(_emitSuperAccessorWrapper(m, type));
         }
 
         if (!hasJsPeer && m.isGetter && m.name.name == 'iterator') {
           hasIterator = true;
           jsMethods.add(_emitIterable(type));
         }
       } else if (m is FieldDeclaration) {
         if (_extensionTypes.isNativeClass(element)) {
           jsMethods.addAll(_emitNativeFieldAccessors(m));
           continue;
@@ skipping 200 matching lines @@
       result.add(new JS.Method(name, setter, isSetter: true));
     }
 
     return result;
   }
 
   /// 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) {
+  JS.Method _emitSuperAccessorWrapper(
+      MethodDeclaration method, InterfaceType type) {
     var methodElement = method.element as PropertyAccessorElement;
     var field = methodElement.variable;
     if (!field.isSynthetic) return null;
-    var propertyOverrideResult =
-        checkForPropertyOverride(methodElement.variable, superclasses);
 
     // Generate a corresponding virtual getter / setter.
     var name = _declareMemberName(methodElement);
     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);
+      if (field.setter == null &&
+          _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);
+      }
     } 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);
+      if (field.getter == null &&
+          _classProperties.inheritedGetters.contains(field.name)) {
+        // Generate a getter that forwards to super.
+        var fn = js.call('function() { return super[#]; }', [name]);
+        return new JS.Method(name, fn, isGetter: true);
+      }
     }
+    return null;
   }
 
   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>
   ///
@@ skipping 93 matching lines @@
           args.add(_emitCallableClassConstructor(member.element));
         }
 
         body.add(_callHelperStatement(code, args));
       }
     }
   }
 
   /// Emits static fields for a class, and initialize them eagerly if possible,
   /// otherwise define them as lazy properties.
-  void _emitStaticFields(
-      List<FieldDeclaration> staticFields,
-      Set<FieldElement> staticFieldOverrides,
-      ClassElement classElem,
-      List<JS.Statement> body) {
+  void _emitStaticFields(List<FieldDeclaration> staticFields,
+      ClassElement classElem, List<JS.Statement> body) {
     var lazyStatics = <VariableDeclaration>[];
     for (FieldDeclaration member in staticFields) {
       for (VariableDeclaration field in member.fields.variables) {
-        JS.Statement eagerField =
-            _emitConstantStaticField(classElem, field, staticFieldOverrides);
+        JS.Statement eagerField = _emitConstantStaticField(classElem, field);
         if (eagerField != null) {
           body.add(eagerField);
         } else {
           lazyStatics.add(field);
         }
       }
     }
     if (lazyStatics.isNotEmpty) {
       body.add(_emitLazyFields(classElem, lazyStatics));
     }
@@ skipping 2187 matching lines @@
   /// dependencies are safe to refer to while we are initializing the class,
   /// then we can initialize it eagerly:
   ///
   ///     // Baz must be const constructor, and the name "Baz" must be defined
   ///     // by this point.
   ///     Foo.bar = dart.const(new Baz(42));
   ///
   /// Otherwise, we'll need to generate a lazy-static field. That ensures
   /// correct visible behavior, as well as avoiding referencing something that
   /// isn't defined yet (because it is defined later in the module).
-  JS.Statement _emitConstantStaticField(ClassElement classElem,
-      VariableDeclaration field, Set<FieldElement> staticFieldOverrides) {
+  JS.Statement _emitConstantStaticField(
+      ClassElement classElem, VariableDeclaration field) {
     PropertyInducingElement element = field.element;
     assert(element.isStatic);
 
     _loader.startCheckingReferences();
     JS.Expression jsInit = _visitInitializer(field);
     bool isLoaded = _loader.finishCheckingReferences();
 
     bool eagerInit =
         isLoaded && (field.isConst || _constants.isFieldInitConstant(field));
 
     var fieldName = field.name.name;
     if (eagerInit &&
         !JS.invalidStaticFieldName(fieldName) &&
-        !staticFieldOverrides.contains(element)) {
+        !_classProperties.staticFieldOverrides.contains(element)) {
       return annotate(
           js.statement('#.# = #;', [
             _emitTopLevelName(classElem),
             _emitMemberName(fieldName, isStatic: true),
             jsInit
           ]),
           field,
           field.element);
     }
 
@@ skipping 945 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 is FieldElement && !member.isSynthetic) {
-      // If super.x is actually a field, then x is an instance property since
+    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)) {
@@ skipping 891 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;
 }