fix #27532, implementing a native type with fields

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 720 matching lines @@
       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);
+        virtualFields, virtualFieldSymbols, staticFieldOverrides, extensions);
 
     var classExpr = _emitClassExpression(classElem,
         _emitClassMethods(node, ctors, fields, superclasses, virtualFields),
         fields: allFields);
 
     var body = <JS.Statement>[];
-    var extensions = _extensionsToImplement(classElem);
     _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);
     _setBaseClass(classElem, className, jsPeerNames, body);
 
     _emitClassTypeTests(classElem, className, body);
 
     _defineNamedConstructors(ctors, body, className, isCallable);
-    _emitVirtualFieldSymbols(virtualFieldSymbols, body);
+    body.addAll(virtualFieldSymbols);
     _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);
     }
@@ skipping 220 matching lines @@
     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) {
+      Set<FieldElement> staticFieldOverrides,
+      Iterable<ExecutableElement> extensionMembers) {
+    var extensionNames =
+        new HashSet<String>.from(extensionMembers.map((e) => e.name));
     for (var field in fields) {
-      for (VariableDeclaration field in field.fields.variables) {
-        var overrideInfo =
-            checkForPropertyOverride(field.element, superclasses);
-        if (overrideInfo.foundGetter || overrideInfo.foundSetter) {
-          if (field.element.isStatic) {
-            staticFieldOverrides.add(field.element);
+      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 fieldName =
-                _emitMemberName(field.element.name, type: classElem.type);
-            var virtualField = new JS.TemporaryId(field.element.name);
-            virtualFields[field.element] = virtualField;
+            var virtualField = new JS.TemporaryId(field.name);
+            virtualFields[field] = virtualField;
             virtualFieldSymbols.add(js.statement(
                 'const # = Symbol(#.name + "." + #.toString());',
-                [virtualField, className, fieldName]));
+                [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);
     }
 
     if (classElem.typeParameters.isNotEmpty) {
       if (callableClass != null) {
         body.add(js.statement('const # = #;', [classExpr.name, callableClass]));
       } else {
         body.add(new JS.ClassDeclaration(classExpr));
       }
     } else {
       body.add(js.statement('# = #;', [className, callableClass ?? classExpr]));
     }
   }
 
-  void _emitVirtualFieldSymbols(
-      List<JS.Statement> virtualFields, List<JS.Statement> body) {
-    body.addAll(virtualFields);
-  }
-
   List<JS.Identifier> _emitTypeFormals(List<TypeParameterElement> typeFormals) {
     return typeFormals
         .map((t) => new JS.Identifier(t.name))
         .toList(growable: false);
   }
 
   /// Emits a field declaration for TypeScript & Closure's ES6_TYPED
   /// (e.g. `class Foo { i: string; }`)
   JS.VariableDeclarationList _emitTypeScriptField(FieldDeclaration field) {
     return new JS.VariableDeclarationList(
@@ skipping 147 matching lines @@
     // Alternatively, perhaps it could be meta-programmed directly in
     // dart.registerExtensions?
     var jsMethods = <JS.Method>[];
     if (!node.isStatic) {
       for (var decl in node.fields.variables) {
         var field = decl.element as FieldElement;
         var name = getAnnotationName(field, isJsName) ?? field.name;
         // Generate getter
         var fn = new JS.Fun([], js.statement('{ return this.#; }', [name]));
         var method =
-            new JS.Method(_elementMemberName(field.getter), fn, isGetter: true);
+            new JS.Method(_declareMemberName(field.getter), fn, isGetter: true);
         jsMethods.add(method);
 
         // Generate setter
         if (!decl.isFinal) {
           var value = new JS.TemporaryId('value');
           fn = new JS.Fun(
               [value], js.statement('{ this.# = #; }', [name, value]));
-          method = new JS.Method(_elementMemberName(field.setter), fn,
+          method = new JS.Method(_declareMemberName(field.setter), fn,
               isSetter: true);
           jsMethods.add(method);
         }
       }
     }
     return jsMethods;
   }
 
   List<JS.Method> _emitClassMethods(
       ClassDeclaration node,
@@ skipping 191 matching lines @@
       } else if (property.isSetter) {
         addProperty('isSetter', js.boolean(true));
 
         fnArgs.add(args);
         positionalArgs = new JS.ArrayInitializer([args]);
       }
     }
 
     var fnBody =
         js.call('this.noSuchMethod(new dart.InvocationImpl(#, #, #))', [
-      _elementMemberName(method),
+      _declareMemberName(method),
       positionalArgs,
       new JS.ObjectInitializer(invocationProps)
     ]);
 
     if (!method.returnType.isDynamic) {
       fnBody = js.call('#._check(#)', [_emitType(method.returnType), fnBody]);
     }
 
     var fn = new JS.Fun(fnArgs, js.statement('{ return #; }', [fnBody]),
         typeParams: _emitTypeFormals(method.type.typeFormals));
 
     // TODO(jmesserly): generic type arguments will get dropped.
     // We have a similar issue with `dgsend` helpers.
     return new JS.Method(
-        _elementMemberName(method,
+        _declareMemberName(method,
             useExtension:
                 _extensionTypes.isNativeClass(method.enclosingElement)),
         _makeGenericFunction(fn),
         isGetter: method is PropertyAccessorElement && method.isGetter,
         isSetter: method is PropertyAccessorElement && method.isSetter,
         isStatic: false);
   }
 
   /// Return `true` if the given [classElement] has a noSuchMethod() method
   /// distinct from the one declared in class Object, as per the Dart Language
@@ skipping 12 matching lines @@
   /// shadowing a field or getter/setter pair on its parent.
   ///
   /// This is important because otherwise, trying to read or write the field
   /// would end up calling the getter or setter, and one of those might not even
   /// exist, resulting in a runtime error. Even if they did exist, that's the
   /// wrong behavior if a new field was declared.
   List<JS.Method> _emitVirtualFieldAccessor(VariableDeclaration field,
       Map<FieldElement, JS.TemporaryId> virtualFields) {
     var virtualField = virtualFields[field.element];
     var result = <JS.Method>[];
-    var name = _emitMemberName(field.element.name,
-        type: (field.element.enclosingElement as ClassElement).type);
+    var name = _declareMemberName((field.element as FieldElement).getter);
     var getter = js.call('function() { return this[#]; }', [virtualField]);
     result.add(new JS.Method(name, getter, isGetter: true));
 
     if (field.isFinal) {
       var setter = js.call('function(value) { super[#] = value; }', [name]);
       result.add(new JS.Method(name, setter, isSetter: true));
     } else {
       var setter =
           js.call('function(value) { this[#] = value; }', [virtualField]);
       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) {
     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 = _elementMemberName(methodElement,
-        useExtension: _extensionTypes.isNativeClass(type.element));
+    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);
     } else {
       // Generate a getter
       if (field.getter != null || !propertyOverrideResult.foundGetter)
         return null;
@@ skipping 142 matching lines @@
 
   /// If a concrete class implements one of our extensions, we might need to
   /// add forwarders.
   void _defineExtensionMembers(List<ExecutableElement> extensions,
       JS.Expression className, List<JS.Statement> body) {
     // If a concrete class implements one of our extensions, we might need to
     // add forwarders.
     if (extensions.isNotEmpty) {
       var methodNames = <JS.Expression>[];
       for (var e in extensions) {
-        methodNames.add(_elementMemberName(e, useExtension: false));
+        methodNames.add(_declareMemberName(e, useExtension: false));
       }
       body.add(js.statement('dart.defineExtensionMembers(#, #);', [
         className,
         new JS.ArrayInitializer(methodNames, multiline: methodNames.length > 4)
       ]));
     }
   }
 
   /// Emit the signature on the class recording the runtime type information
   void _emitClassSignature(
@@ skipping 45 matching lines @@
       type = _emitAnnotatedFunctionType(element.type, node.metadata,
           parameters: node.parameters?.parameters,
           nameType: options.hoistSignatureTypes,
           hoistType: options.hoistSignatureTypes,
           definite: true);
 
       var inheritedElement = lookup(name, currentLibrary);
       if (inheritedElement != null && inheritedElement.type == element.type) {
         continue;
       }
-      var memberName = _elementMemberName(element,
-          useExtension: _extensionTypes.isNativeClass(classElem));
+      var memberName = _declareMemberName(element);
       var property = new JS.Property(memberName, type);
       tMember.add(property);
       // TODO(vsm): Why do we need this?
       if (node.isStatic && !node.isGetter && !node.isSetter) {
         sNames.add(memberName);
       }
     }
 
     var tInstanceFields = <JS.Property>[];
     var tStaticFields = <JS.Property>[];
     for (FieldDeclaration node in fields) {
       for (VariableDeclaration field in node.fields.variables) {
         var element = field.element as FieldElement;
-        var memberName = _elementMemberName(element.getter,
-            useExtension: _extensionTypes.isNativeClass(classElem));
+        var memberName = _declareMemberName(element.getter);
         var type = _emitAnnotatedType(element.type, node.metadata);
         var property = new JS.Property(memberName, type);
         (node.isStatic ? tStaticFields : tInstanceFields).add(property);
       }
     }
 
     var tCtors = <JS.Property>[];
     for (ConstructorDeclaration node in ctors) {
       var memberName = _constructorName(node.element);
       var element = node.element;
@@ skipping 62 matching lines @@
   /// Ensure `dartx.` symbols we will use are present.
   void _initExtensionSymbols(
       ClassElement classElem,
       List<MethodDeclaration> methods,
       List<FieldDeclaration> fields,
       List<JS.Statement> body) {
     if (_extensionTypes.hasNativeSubtype(classElem.type)) {
       var dartxNames = <JS.Expression>[];
       for (var m in methods) {
         if (!m.isAbstract && !m.isStatic && m.element.isPublic) {
-          dartxNames.add(_elementMemberName(m.element, useExtension: false));
+          dartxNames.add(_declareMemberName(m.element, useExtension: false));
         }
       }
       for (var fieldDecl in fields) {
         if (!fieldDecl.isStatic) {
           for (var field in fieldDecl.fields.variables) {
             var e = field.element as FieldElement;
             if (e.isPublic) {
-              dartxNames.add(_elementMemberName(e.getter, useExtension: false));
+              dartxNames.add(_declareMemberName(e.getter, useExtension: false));
             }
           }
         }
       }
       if (dartxNames.isNotEmpty) {
         body.add(js.statement('dart.defineExtensionNames(#)',
             [new JS.ArrayInitializer(dartxNames, multiline: true)]));
       }
     }
   }
@@ skipping 283 matching lines @@
       if (fieldNode.initializer != null) {
         value = _visit(fieldNode.initializer);
       } else {
         value = new JS.LiteralNull();
       }
       fields[element] = value;
     });
 
     var body = <JS.Statement>[];
     fields.forEach((FieldElement e, JS.Expression initialValue) {
-      if (virtualFields.containsKey(e)) {
-        body.add(
-            js.statement('this[#] = #;', [virtualFields[e], initialValue]));
-      } else {
-        var access = _emitMemberName(e.name, type: e.enclosingElement.type);
-        body.add(js.statement('this.# = #;', [access, initialValue]));
-      }
+      JS.Expression access = virtualFields[e] ?? _declareMemberName(e.getter);
+      body.add(js.statement('this.# = #;', [access, initialValue]));
     });
 
     if (isConst) _loader.finishTopLevel(cls.element);
     return _statement(body);
   }
 
   FormalParameterList _parametersOf(node) {
     // TODO(jmesserly): clean this up. If we can model ES6 spread/rest args, we
     // could handle argument initializers more consistently in a separate
     // lowering pass.
@@ skipping 117 matching lines @@
           fn.params.isNotEmpty) {
         // []= methods need to return the value. We could also address this at
         // call sites, but it's cleaner to instead transform the operator method.
         fn = _alwaysReturnLastParameter(fn);
       }
 
       fn = _makeGenericFunction(fn);
     }
 
     return annotate(
-        new JS.Method(
-            _elementMemberName(node.element,
-                useExtension: _extensionTypes.isNativeClass(type.element)),
-            fn,
+        new JS.Method(_declareMemberName(node.element), fn,
             isGetter: node.isGetter,
             isSetter: node.isSetter,
             isStatic: node.isStatic),
         node,
         node.element);
   }
 
   /// Transform the function so the last parameter is always returned.
   ///
   /// This is useful for indexed set methods, which otherwise would not have
@@ skipping 2896 matching lines @@
     }
     JS.Expression result = _visit(node);
     if (isNullable(node)) result = js.call('dart.test(#)', result);
     return result;
   }
 
   /// Like [_emitMemberName], but for declaration sites.
   ///
   /// Unlike call sites, we always have an element available, so we can use it
   /// directly rather than computing the relevant options for [_emitMemberName].
-  JS.Expression _elementMemberName(ExecutableElement e, {bool useExtension}) {
+  JS.Expression _declareMemberName(ExecutableElement e, {bool useExtension}) {
     String name;
     if (e is PropertyAccessorElement) {
       name = e.variable.name;
     } else {
       name = e.name;
     }
     return _emitMemberName(name,
-        type: (e.enclosingElement as ClassElement).type,
         unary: e.parameters.isEmpty,
         isStatic: e.isStatic,
-        useExtension: useExtension);
+        useExtension:
+            useExtension ?? _extensionTypes.isNativeClass(e.enclosingElement));
   }
 
   /// This handles member renaming for private names and operators.
   ///
   /// Private names are generated using ES6 symbols:
   ///
   ///     // At the top of the module:
   ///     let _x = Symbol('_x');
   ///     let _y = Symbol('_y');
   ///     ...
@@ skipping 277 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';