[vm] Late modifier for non-static final fields.

Bug: #38841
Change-Id: Ib2b3189b20bd056b6378fa5d7a6166acef9a5c67
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/124465
Reviewed-by: Régis Crelier <regis@google.com>
Reviewed-by: Alexander Markov <alexmarkov@google.com>
Commit-Queue: Liam Appelbe <liama@google.com>

Author: liamappelbe

runtime/vm/compiler/backend/flow_graph_compiler.cc

@@ -1209,6 +1209,7 @@ bool FlowGraphCompiler::TryIntrinsifyHelper() {
         // Only intrinsify getter if the field cannot contain a mutable double.
         // Reading from a mutable double box requires allocating a fresh double.
         if (field.is_instance() && !field.needs_load_guard() &&
+            !field.is_late() &&
             (FLAG_precompiled_mode || !IsPotentialUnboxedField(field))) {
           SpecialStatsBegin(CombinedCodeStatistics::kTagIntrinsics);
           GenerateGetterIntrinsic(compiler::target::Field::OffsetOf(field));

runtime/vm/compiler/frontend/kernel_to_il.cc

@@ -465,6 +465,61 @@ Fragment FlowGraphBuilder::LoadLateField(const Field& field,
   return instructions;
 }
 
+Fragment FlowGraphBuilder::StoreLateInstanceField(const Field& field,
+                                                  LocalVariable* instance,
+                                                  LocalVariable* setter_value) {
+  // Implicit setters for non-final late fields are the same as non-late fields.
+  if (!field.is_final()) {
+    return StoreInstanceFieldGuarded(field,
+                                     StoreInstanceFieldInstr::Kind::kOther);
+  }
+
+  // If a late final field has an initializer, the setter always throws. This
+  // case is typically caught as a compile error, but there are ways to avoid
+  // that error, so we also need this runtime error.
+  const TokenPosition position = field.token_pos();
+  if (field.has_initializer()) {
+    Fragment instructions;
+    instructions += Drop();
+    instructions += Drop();
+    instructions += ThrowLateInitializationError(
+        position, String::ZoneHandle(Z, field.name()));
+    return instructions;
+  }
+
+  // Late final fields with no initializer can be written to once.
+  Fragment instructions;
+  TargetEntryInstr *is_uninitialized, *is_initialized;
+
+  // Check whether the field has been initialized already.
+  instructions += Drop();
+  instructions += LoadField(field);
+  instructions += Constant(Object::sentinel());
+  instructions += BranchIfStrictEqual(&is_uninitialized, &is_initialized);
+
+  JoinEntryInstr* join = BuildJoinEntry();
+
+  {
+    // If the field isn't initialized, set it to the new value.
+    Fragment initialize(is_uninitialized);
+    initialize += LoadLocal(instance);
+    initialize += LoadLocal(setter_value);
+    initialize +=
+        StoreInstanceFieldGuarded(field, StoreInstanceFieldInstr::Kind::kOther);
+    initialize += Goto(join);
+  }
+
+  {
+    // If the field is already initialized, throw a LateInitializationError.
+    Fragment already_initialized(is_initialized);
+    already_initialized += ThrowLateInitializationError(
+        position, String::ZoneHandle(Z, field.name()));
+    already_initialized += Goto(join);
+  }
+
+  return Fragment(instructions.entry, join);
+}
+
 Fragment FlowGraphBuilder::ThrowLateInitializationError(TokenPosition position,
                                                         const String& name) {
   const Class& klass = Class::ZoneHandle(
@@ -2568,8 +2623,13 @@ FlowGraph* FlowGraphBuilder::BuildGraphOfFieldAccessor(
                               AssertAssignableInstr::kParameterCheck);
     }
     if (is_method) {
-      body += StoreInstanceFieldGuarded(field,
-                                        StoreInstanceFieldInstr::Kind::kOther);
+      if (field.is_late()) {
+        body += StoreLateInstanceField(
+            field, parsed_function_->ParameterVariable(0), setter_value);
+      } else {
+        body += StoreInstanceFieldGuarded(
+            field, StoreInstanceFieldInstr::Kind::kOther);
+      }
     } else {
       body += StoreStaticField(TokenPosition::kNoSource, field);
     }

runtime/vm/compiler/frontend/kernel_to_il.h

@@ -133,6 +133,9 @@ class FlowGraphBuilder : public BaseFlowGraphBuilder {
   Fragment RethrowException(TokenPosition position, int catch_try_index);
   Fragment LoadLocal(LocalVariable* variable);
   Fragment LoadLateField(const Field& field, LocalVariable* instance);
+  Fragment StoreLateInstanceField(const Field& field,
+                                  LocalVariable* instance,
+                                  LocalVariable* setter_value);
   Fragment InitInstanceField(const Field& field);
   Fragment InitStaticField(const Field& field);
   Fragment NativeCall(const String* name, const Function* function);

tests/language_2/nnbd/syntax/late_modifier_final_field_test.dart

@@ -0,0 +1,59 @@
+// 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.
+
+// SharedOptions=--enable-experiment=non-nullable
+import 'package:expect/expect.dart';
+
+int initCalls = 0;
+int init() {
+  ++initCalls;
+  return 123;
+}
+
+class Base {
+  late final int fieldWithInit;
+}
+
+// A inherits from Base to bypass the compile time error caused by assigning to
+// a late final field that has an initializer. This allows us to test the
+// runtime exception.
+class A extends Base {
+  late final int fieldWithInit = init();
+}
+
+class B {
+  late final int fieldWithNoInit;
+}
+
+main() {
+  Base a = A();
+  Expect.equals(0, initCalls);
+  Expect.equals(123, a.fieldWithInit);
+  Expect.equals(1, initCalls);
+  Expect.equals(123, a.fieldWithInit);
+  Expect.equals(1, initCalls);
+  Expect.throws(() => {a.fieldWithInit = 456},
+      (error) => error is LateInitializationError);
+  Expect.equals(1, initCalls);
+  Expect.equals(123, a.fieldWithInit);
+  Expect.equals(1, initCalls);
+  initCalls = 0;
+
+  Base a2 = A();
+  Expect.equals(0, initCalls);
+  Expect.throws(() => {a2.fieldWithInit = 456},
+      (error) => error is LateInitializationError);
+  Expect.equals(0, initCalls);
+  Expect.equals(123, a2.fieldWithInit);
+  Expect.equals(1, initCalls);
+
+  B b = B();
+  Expect.throws(
+      () => b.fieldWithNoInit, (error) => error is LateInitializationError);
+  b.fieldWithNoInit = 123;
+  Expect.equals(123, b.fieldWithNoInit);
+  Expect.throws(() => {b.fieldWithNoInit = 456},
+      (error) => error is LateInitializationError);
+  Expect.equals(123, b.fieldWithNoInit);
+}