Fix #28120, strong mode allows field overrides

pkg/dev_compiler/test/codegen_expected/closure.js

 export const closure = Object.create(null);
 import { core, js, dart, dartx } from 'dart_sdk';
 let dynamic__Toint = () => (dynamic__Toint = dart.constFn(dart.functionType(core.int, [dart.dynamic], [dart.dynamic])))();
 let dynamic__Todynamic = () => (dynamic__Todynamic = dart.constFn(dart.functionType(dart.dynamic, [dart.dynamic], {y: core.String, z: dart.dynamic})))();
 let StringToList = () => (StringToList = dart.constFn(dart.functionType(core.List, [core.String])))();
 let ListOfint = () => (ListOfint = dart.constFn(core.List$(core.int)))();
 let dynamicTodynamic = () => (dynamicTodynamic = dart.constFn(dart.functionType(dart.dynamic, [dart.dynamic])))();
 let FnToListOfint = () => (FnToListOfint = dart.constFn(dart.functionType(ListOfint(), [dynamicTodynamic()])))();
 let MapOfMap$Map = () => (MapOfMap$Map = dart.constFn(core.Map$(core.Map, core.Map)))();
 let Foo = () => (Foo = dart.constFn(closure.Foo$()))();
@@ skipping 11 matching lines @@
 closure.Foo$ = dart.generic(T => {
   let FooOfT = () => (FooOfT = dart.constFn(closure.Foo$(T)))();
   class Foo<T> extends core.Object {
     i: number;
     b: boolean;
     s: string;
     v: T;
     static some_static_constant: string;
     static some_static_final: string;
     static some_static_var: string;
+    get i() {
+      return this[i$];
+    }
+    set i(value) {
+      super.i = value;
+    }
+    get b() {
+      return this[b];
+    }
+    set b(value) {
+      this[b] = value;
+    }
+    get s() {
+      return this[s];
+    }
+    set s(value) {
+      this[s] = value;
+    }
+    get v() {
+      return this[v$];
+    }
+    set v(value) {
+      this[v$] = value;
+    }
     new(i: number, v: T) {
-      this.i = i;
-      this.v = v;
-      this.b = null;
-      this.s = null;
+      this[i$] = i;
+      this[v$] = v;
+      this[b] = null;
+      this[s] = null;
     }
     static build() {
       return new (FooOfT())(1, null);
     }
     untyped_method(a, b) {}
     pass(t: T) {
       T._check(t);
       return t;
     }
     typed_method(foo: closure.Foo<any>, list: core.List<any>, i: number, n: number, d: number, b: boolean, s: string, a: any[], o: Object, f: Function) {
       return '';
     }
     optional_params(a, b = null, c: number = null) {}
     static named_params(a, {b = null, c = null}: {b?: any, c?: number} = {}) {}
     nullary_method() {}
     function_params(f: (x: any, y?: any) => number, g: (x: any, opts?: {y?: string, z?: any}) => any, cb: closure.Callback) {
       cb({i: this.i});
     }
     run(a: core.List<any>, b: string, c: (d: string) => core.List<any>, e: (f: (g: any) => any) => core.List<number>, {h = null}: {h?: core.Map<core.Map<any, any>, core.Map<any, any>>} = {}) {}
     get prop() {
       return null;
     }
     set prop(value: string) {}
     static get staticProp() {
       return null;
     }
     static set staticProp(value: string) {}
   }
   dart.addTypeTests(Foo);
+  const i$ = Symbol("Foo.i");
+  const b = Symbol("Foo.b");
+  const s = Symbol("Foo.s");
+  const v$ = Symbol("Foo.v");
   dart.setSignature(Foo, {
     fields: () => ({
       i: core.int,
       b: core.bool,
       s: core.String,
       v: T
     }),
     getters: () => ({prop: dart.definiteFunctionType(core.String, [])}),
     setters: () => ({prop: dart.definiteFunctionType(dart.void, [core.String])}),
     methods: () => ({
@@ skipping 35 matching lines @@
   },
   set closure(_) {}
 });
 /** @final {string} */
 closure.some_top_level_constant = "abc";
 /** @final {string} */
 closure.some_top_level_final = "abc";
 /** @type {string} */
 closure.some_top_level_var = "abc";
 dart.trackLibraries("closure", {"closure.dart": closure}, null);