consider eliminating final fields with trivial initializers

[mraleph]

const y = 0xDEADBEEF;
final int x = 0xFEEDFEED;

void main(List<String> args) {
  print(x);
  print(y);
  print(x + y);
}

results in:

*** BEGIN CFG
After AllocateRegisters
==== file:///usr/local/google/home/vegorov/src/temp/tst/bin/tst.dart_::_main (RegularFunction)
  0: B0[graph]:0 {
      v0 <- Constant(#null) T{Null?}
      v5 <- Constant(#3735928559) [3735928559, 3735928559] T{_Smi}
      v18 <- UnboxedConstant(#3735928559 int64) [3735928559, 3735928559] T{_Smi}
}
  2: B1[function entry]:2 {
      v2 <- Parameter(0) T{List<String>}
}
  4:     CheckStackOverflow:8(stack=0, loop=0)
  6:     v3 <- LoadStaticField(x) T{int?}
  7:     ParallelMove S-1 <- rax
  8:     PushArgument(v3)
 10:     StaticCall:12( print<0> v3)
 12:     PushArgument(v5)
 14:     StaticCall:14( print<0> v5)
 15:     ParallelMove rax <- S-1
 16:     CheckNull:16(v3 T{int?}, NoSuchMethodError) [-9223372036854775808, 9223372036854775807] T{int}
 18:     ParallelMove rax <- rax
 18:     v14 <- UnboxInt64([non-speculative], v3 T{int}) [-9223372036854775808, 9223372036854775807] T{int}
 20:     ParallelMove rcx <- rax
 20:     v8 <- BinaryInt64Op(+ [tr], v14 T{int}, v18) [-9223372036854775808, 9223372036854775807] T{int}
 22:     v16 <- BoxInt64(v8) [-9223372036854775808, 9223372036854775807] T{int}
 23:     ParallelMove rax <- rax
 24:     PushArgument(v16 T{int})
 26:     StaticCall:18( print<0> v16 T{int})
 27:     ParallelMove rax <- C
 28:     Return:22(v0)
*** END CFG

We should probably eliminate the field altogether by inlining all LoadStaticField from it.

/cc @alexmarkov

[alexmarkov]

I see the following ways of fixing this:

1. Implement constant evaluation on kernel AST outside of const context (Extend kernel constant evaluator to handle constant expressions in non-constant contexts #34585). Improved constant evaluation could evaluate StaticGet of a final static field with a constant value on AST.

2. Extend whole-program constant propagation in TFA to handle large integer constants. Final static fields initialized with small int constants are already optimized:

final int x = 42;

void main() {
  print(x);
}

  0: B0[graph]:0 {
      v0 <- Constant(#null) T{Null?}
      v2 <- Constant(#42) [42, 42] T{_Smi}
}
  2: B1[function entry]:2
  4:     CheckStackOverflow:8(stack=0, loop=0)
  6:     PushArgument(v2)
  8:     StaticCall:12( print<0> v2)
  9:     ParallelMove rax <- C
 10:     Return:16(v0)

TFA propagates constants along with a concrete known type. The problem is that type of a large int constant (>31 bits) depends on the target architecture (32-bit/64-bit/64-bit with compressed pointers) and can be either Smi or Mint, and kernel compiler currently is portable and doesn't know about the target architecture.

3. Handle this case when generating flow graph for StaticGet in flow graph builder. CL: https://dart-review.googlesource.com/c/sdk/+/212873.