[vm/compiler] Fix type of Parameter in a CatchBlockEntry

Parameter in a CatchBlockEntry may correspond to a late local variable
which was not initialized yet, so its type should correctly state
that it can be sentinel.

TEST=vm/dart/flutter_regress_109261_test
Fixes flutter/flutter#109261

Change-Id: Ia6fbbe4b9963323f84438b3f618437276e51f256
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/254440
Commit-Queue: Alexander Markov <alexmarkov@google.com>
Reviewed-by: Martin Kustermann <kustermann@google.com>

runtime/tests/vm/dart/flutter_regress_109261_test.dart

@@ -0,0 +1,69 @@
+// Copyright (c) 2022, 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.
+
+// Regression test for https://github.com/flutter/flutter/issues/109261.
+// Varifies that uninitialized final late local variable can be correctly
+// used in a catch block.
+
+import 'package:expect/expect.dart';
+
+void testWriteToUninitialized() {
+  late final int computationResult;
+
+  try {
+    throw 'bye';
+  } catch (e, s) {
+    computationResult = 42;
+  }
+
+  Expect.equals(42, computationResult);
+}
+
+void testWriteToInitialized() {
+  Expect.throws(() {
+    late final int computationResult;
+
+    try {
+      computationResult = 10;
+      throw 'bye';
+    } catch (e, s) {
+      computationResult = 42;
+    }
+  });
+}
+
+void testReadFromUninitialized() {
+  Expect.throws(() {
+    late final int computationResult;
+
+    try {
+      if (int.parse('1') == 2) {
+        // Unreachable, just to avoid compile-time error "Late variable '...'
+        // without initializer is definitely unassigned."
+        computationResult = 10;
+      }
+      throw 'bye';
+    } catch (e, s) {
+      print(computationResult);
+    }
+  });
+}
+
+void testReadFromInitialized() {
+  late final int computationResult;
+
+  try {
+    computationResult = 10;
+    throw 'bye';
+  } catch (e, s) {
+    Expect.equals(10, computationResult);
+  }
+}
+
+main() {
+  testWriteToUninitialized();
+  testWriteToInitialized();
+  testReadFromUninitialized();
+  testReadFromInitialized();
+}

runtime/vm/compiler/backend/compile_type.h

@@ -145,6 +145,8 @@ class CompileType : public ZoneAllocated {
   // represent unknown type.
   static CompileType Dynamic();
 
+  static CompileType DynamicOrSentinel();
+
   static CompileType Null();
 
   // Create non-nullable Bool type.

runtime/vm/compiler/backend/type_propagator.cc

@@ -686,6 +686,11 @@ CompileType CompileType::Dynamic() {
                      &Object::dynamic_type());
 }
 
+CompileType CompileType::DynamicOrSentinel() {
+  return CompileType(kCanBeNull, kCanBeSentinel, kDynamicCid,
+                     &Object::dynamic_type());
+}
+
 CompileType CompileType::Null() {
   return CompileType(kCanBeNull, kCannotBeSentinel, kNullCid,
                      &Type::ZoneHandle(Type::NullType()));
@@ -1264,6 +1269,11 @@ CompileType ParameterInstr::ComputeType() const {
     }
   }
 
+  if (block_->IsCatchBlockEntry()) {
+    // Parameter of a catch block may correspond to a late local variable.
+    return CompileType::DynamicOrSentinel();
+  }
+
   return CompileType::Dynamic();
 }