[dartdevc] fix for const / overridden fields

Fixes #37839

Change-Id: Ibe7b151e8e5fdd4d83cf5b69d49c7b3d17a1cefe
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/113136
Commit-Queue: Vijay Menon <[email protected]>
Reviewed-by: Mark Zhou <[email protected]>

Author: vsmenon

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

@@ -252,6 +252,7 @@ abstract class SharedCompiler<Library, Class, InterfaceType, FunctionNode> {
     /// runtime call.
     js_ast.TemporaryId initPrivateNameSymbol() {
       var idName = name.endsWith('=') ? name.replaceAll('=', '_') : name;
+      idName = idName.replaceAll('.', '_');
       var id = js_ast.TemporaryId(idName);
       moduleItems.add(js.statement('const # = #.privateName(#, #)',
           [id, runtimeModule, emitLibraryName(library), js.string(name)]));
@@ -262,6 +263,16 @@ abstract class SharedCompiler<Library, Class, InterfaceType, FunctionNode> {
     return privateNames.putIfAbsent(name, initPrivateNameSymbol);
   }
 
+  /// Emits a private name JS Symbol for [name] unique to a Dart class [cls].
+  ///
+  /// This is now required for fields of constant objects that may be
+  /// overridden within the same library.
+  @protected
+  js_ast.TemporaryId emitClassPrivateNameSymbol(
+      Library library, String className, String memberName) {
+    return emitPrivateNameSymbol(library, '$className.$memberName');
+  }
+
   /// Emits an expression to set the property [nameExpr] on the class [className],
   /// with [value].
   ///

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

@@ -2795,10 +2795,9 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
 
   void _emitVirtualFieldSymbols(Class c, List<js_ast.Statement> body) {
     _classProperties.virtualFields.forEach((field, virtualField) {
-      body.add(js.statement('const # = Symbol(#);', [
-        virtualField,
-        js.string('${getLocalClassName(c)}.${field.name.name}')
-      ]));
+      var symbol = emitClassPrivateNameSymbol(
+          c.enclosingLibrary, getLocalClassName(c), field.name.name);
+      body.add(js.statement('const # = #;', [virtualField, symbol]));
     });
   }
 
@@ -5405,8 +5404,15 @@ class ProgramCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     entryToProperty(MapEntry<Reference, Constant> entry) {
       var constant = visitConstant(entry.value);
       var member = entry.key.asField;
-      return js_ast.Property(
-          _emitMemberName(member.name.name, member: member), constant);
+      var cls = member.enclosingClass;
+      // Enums cannot be overridden, so we can safely use the field name
+      // directly.  Otherwise, use a private symbol in case the field
+      // was overridden.
+      var symbol = cls.isEnum
+          ? _emitMemberName(member.name.name, member: member)
+          : emitClassPrivateNameSymbol(
+              cls.enclosingLibrary, getLocalClassName(cls), member.name.name);
+      return js_ast.Property(symbol, constant);
     }
 
     var type = visitInterfaceType(node.getType(_types) as InterfaceType);

pkg/dev_compiler/lib/src/kernel/property_model.dart

@@ -161,6 +161,13 @@ class _LibraryVirtualFieldModel {
       if (_extensiblePrivateClasses.contains(class_)) return true;
     }
 
+    if (class_.constructors.any((c) => c.isConst)) {
+      // Always virtualize fields of a (might be) non-enum (see above) const
+      // class.  The way these are lowered by the CFE, they need to be
+      // writable from different modules even if overridden.
+      return true;
+    }
+
     // Otherwise, the field is effectively private and we only need to make it
     // virtual if it's overridden.
     return _overriddenPrivateFields.contains(field);

tests/language_2/override_const_field_test.dart

@@ -0,0 +1,23 @@
+// Copyright (c) 2019, 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.
+// Dart test checking that static/instance field shadowing do not conflict.
+
+import 'package:expect/expect.dart';
+
+class A {
+  final field;
+  const A(this.field);
+}
+
+class B extends A {
+  final field;
+  const B(this.field, fieldA) : super(fieldA);
+  get fieldA => super.field;
+}
+
+main() {
+  const b = B(1, 2);
+  Expect.equals(1, b.field);
+  Expect.equals(2, b.fieldA);
+}