Reapply "[dart2js] Do some load elimination in simplifier"

This reverts commit 3f2befe.

Change-Id: I551b1dcc058b833bf208164eb787aaad68b9341b
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/433267
Reviewed-by: Nate Biggs <[email protected]>
Commit-Queue: Stephen Adams <[email protected]>

Author: rakudrama

pkg/compiler/lib/src/ssa/optimize.dart

@@ -1821,9 +1821,61 @@ class SsaInstructionSimplifier extends HBaseVisitor<HInstruction>
       }
     }
 
+    // HFieldGet of a final field from an allocator can be replaced with the
+    // field's value.
+    //
+    // Load Elimination is more powerful as it can handle non-final fields, but
+    // doing this earlier in the simplifier generates more opportunities for the
+    // first GVN pass.
+    if (receiver is HCreate && !node.isAssignable) {
+      int index = _indexOfFieldInAllocatorInputs(
+        receiver.element,
+        node.element,
+      );
+      if (index >= 0) return receiver.inputs[index];
+    }
+
     return node;
   }
 
+  int _indexOfFieldInAllocatorInputs(ClassEntity cls, FieldEntity field) {
+    final classCache = _indexOfFieldInAllocatorCache ??= {};
+    final fieldCache = classCache[cls] ??= {};
+    final index = fieldCache[field];
+    if (index != null) return index;
+
+    int argumentIndex = 0;
+    _closedWorld.elementEnvironment.forEachInstanceField(cls, (
+      _,
+      FieldEntity member,
+    ) {
+      FieldAnalysisData fieldData = _closedWorld.fieldAnalysis.getFieldData(
+        member,
+      );
+      int index = (fieldData.isElided || fieldData.isInitializedInAllocator)
+          ? -1
+          : argumentIndex++;
+
+      // TODO(https://github.com/dart-lang/sdk/issues/26775): dart2js has a bug
+      // with using the same mixin twice, the fields are not separated, so can
+      // occur here twice. If we already have an index, one of them is wrong.
+      if (fieldCache[member] != null) index = -1;
+
+      fieldCache[member] = index;
+    });
+
+    if (fieldCache[field] == null) {
+      // The field should not be missing but it might be possible (1) with
+      // unsound optimizations due to 'trusted' checks (-O3), and (2) attempting
+      // to compile an abstract class generative constructor (a bit unclear why
+      // this happens, see b/422944368).
+      return fieldCache[field] = -1;
+    }
+    return fieldCache[field]!;
+  }
+
+  Map<ClassEntity, Map<FieldEntity, int>>? _indexOfFieldInAllocatorCache;
+
   @override
   HInstruction visitGetLength(HGetLength node) {
     HInstruction receiver = node.receiver;