Version 2.13.2

* Cherry-pick 6d0f90e to stable
* Cherry-pick a3767f7 to stable
* Cherry-pick ed82bb6 to stable
* Cherry-pick 8eba520 to stable

Author: athomas

CHANGELOG.md

@@ -1,3 +1,17 @@
+## 2.13.2 - 2021-06-09
+
+This is a patch release that fixes:
+
+* a Dart compiler crash (issue [flutter/flutter#83094][]).
+* an analysis server deadlock causing it to stop responding to IDE requests
+  (issue [#45996][]).
+* an analyzer crash when analyzing against `package:meta` `v1.4.0` (issue
+  [#46183][]).
+
+[flutter/flutter#83094]: https://github.com/flutter/flutter/issues/83094
+[#45996]: https://github.com/dart-lang/sdk/issues/45996
+[#46183]: https://github.com/dart-lang/sdk/issues/46183
+
 ## 2.13.1 - 2021-05-25
 
 This is a patch release that fixes:

pkg/analyzer/lib/src/error/best_practices_verifier.dart

@@ -41,6 +41,10 @@ import 'package:meta/meta_meta.dart';
 class BestPracticesVerifier extends RecursiveAstVisitor<void> {
   static const String _TO_INT_METHOD_NAME = "toInt";
 
+  static final Map<String, TargetKind> _targetKindsByName = {
+    for (final kind in TargetKind.values) kind.toString(): kind,
+  };
+
   /// The class containing the AST nodes being visited, or `null` if we are not
   /// in the scope of a class.
   ClassElementImpl? _enclosingClass;
@@ -1596,9 +1600,23 @@ class BestPracticesVerifier extends RecursiveAstVisitor<void> {
       if (annotation.isTarget) {
         var value = annotation.computeConstantValue()!;
         var kinds = <TargetKind>{};
+
         for (var kindObject in value.getField('kinds')!.toSetValue()!) {
+          // We can't directly translate the index from the analyzed TargetKind
+          // constant to TargetKinds.values because the analyzer from the SDK
+          // may have been compiled with a different version of pkg:meta.
           var index = kindObject.getField('index')!.toIntValue()!;
-          kinds.add(TargetKind.values[index]);
+          var targetKindClass =
+              (kindObject.type as InterfaceType).element as EnumElementImpl;
+          // Instead, map constants to their TargetKind by comparing getter
+          // names.
+          var getter = targetKindClass.constants[index];
+          var name = 'TargetKind.${getter.name}';
+
+          var foundTargetKind = _targetKindsByName[name];
+          if (foundTargetKind != null) {
+            kinds.add(foundTargetKind);
+          }
         }
         return kinds;
       }

runtime/bin/file_system_watcher_macos.cc

@@ -82,89 +82,44 @@ class FSEventsWatcher {
     void set_ref(FSEventStreamRef ref) { ref_ = ref; }
 
     void Start() {
-      // Schedule StartCallback to be executed in the RunLoop.
-      CFRunLoopTimerContext context;
-      memset(&context, 0, sizeof(context));
-      context.info = this;
-      CFRunLoopTimerRef timer =
-          CFRunLoopTimerCreate(NULL, 0, 0, 0, 0, Node::StartCallback, &context);
-      CFRunLoopAddTimer(watcher_->run_loop_, timer, kCFRunLoopCommonModes);
-      CFRelease(timer);
-      watcher_->monitor_.Enter();
-      while (!ready_) {
-        watcher_->monitor_.Wait(Monitor::kNoTimeout);
-      }
-      watcher_->monitor_.Exit();
-    }
-
-    static void StartCallback(CFRunLoopTimerRef timer, void* info) {
-      Node* node = reinterpret_cast<Node*>(info);
-      ASSERT(Thread::Compare(node->watcher_->threadId_,
-                             Thread::GetCurrentThreadId()));
       FSEventStreamContext context;
       memset(&context, 0, sizeof(context));
-      context.info = reinterpret_cast<void*>(node);
+      context.info = reinterpret_cast<void*>(this);
       CFArrayRef array = CFArrayCreate(
-          NULL, reinterpret_cast<const void**>(&node->path_ref_), 1, NULL);
+          NULL, reinterpret_cast<const void**>(&path_ref_), 1, NULL);
       FSEventStreamRef ref = FSEventStreamCreate(
           NULL, Callback, &context, array, kFSEventStreamEventIdSinceNow, 0.10,
           kFSEventStreamCreateFlagFileEvents);
       CFRelease(array);
 
-      node->set_ref(ref);
+      set_ref(ref);
+      ready_.store(true, std::memory_order_release);
 
-      FSEventStreamScheduleWithRunLoop(node->ref_, node->watcher_->run_loop_,
+      FSEventStreamScheduleWithRunLoop(ref_, watcher_->run_loop_,
                                        kCFRunLoopDefaultMode);
 
-      FSEventStreamStart(node->ref_);
-      FSEventStreamFlushSync(node->ref_);
-
-      node->watcher_->monitor_.Enter();
-      node->ready_ = true;
-      node->watcher_->monitor_.Notify();
-      node->watcher_->monitor_.Exit();
+      FSEventStreamStart(ref_);
+      FSEventStreamFlushSync(ref_);
     }
 
     void Stop() {
-      // Schedule StopCallback to be executed in the RunLoop.
       ASSERT(ready_);
-      CFRunLoopTimerContext context;
-      memset(&context, 0, sizeof(context));
-      context.info = this;
-      CFRunLoopTimerRef timer =
-          CFRunLoopTimerCreate(NULL, 0, 0, 0, 0, StopCallback, &context);
-      CFRunLoopAddTimer(watcher_->run_loop_, timer, kCFRunLoopCommonModes);
-      CFRelease(timer);
-      watcher_->monitor_.Enter();
-      while (ready_) {
-        watcher_->monitor_.Wait(Monitor::kNoTimeout);
-      }
-      watcher_->monitor_.Exit();
-    }
-
-    static void StopCallback(CFRunLoopTimerRef timer, void* info) {
-      Node* node = reinterpret_cast<Node*>(info);
-      ASSERT(Thread::Compare(node->watcher_->threadId_,
-                             Thread::GetCurrentThreadId()));
-      FSEventStreamStop(node->ref_);
-      FSEventStreamInvalidate(node->ref_);
-      FSEventStreamRelease(node->ref_);
-      node->watcher_->monitor_.Enter();
-      node->ready_ = false;
-      node->watcher_->monitor_.Notify();
-      node->watcher_->monitor_.Exit();
+      FSEventStreamStop(ref_);
+      FSEventStreamInvalidate(ref_);
+      FSEventStreamRelease(ref_);
+      ready_.store(false, std::memory_order_release);
     }
 
     FSEventsWatcher* watcher() const { return watcher_; }
-    bool ready() const { return ready_; }
+    bool ready() const { return ready_.load(std::memory_order_acquire); }
     intptr_t base_path_length() const { return base_path_length_; }
     int read_fd() const { return read_fd_; }
     int write_fd() const { return write_fd_; }
     bool recursive() const { return recursive_; }
 
    private:
     FSEventsWatcher* watcher_;
-    bool ready_;
+    std::atomic<bool> ready_;
     intptr_t base_path_length_;
     CFStringRef path_ref_;
     int read_fd_;
@@ -266,8 +221,6 @@ class FSEventsWatcher {
     Node* node = reinterpret_cast<Node*>(client);
     ASSERT(Thread::Compare(node->watcher()->threadId_,
                            Thread::GetCurrentThreadId()));
-    // `ready` is set on same thread as this callback is invoked, so we don't
-    // need to lock here.
     if (!node->ready()) {
       return;
     }

runtime/tests/vm/dart/regress_flutter83094_test.dart

@@ -0,0 +1,27 @@
+// Copyright (c) 2021, 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.
+
+// Verifies that compiler doesn't crash due to incompatible types
+// when unboxing input of a Phi.
+// Regression test for https://github.com/flutter/flutter/issues/83094.
+
+import 'package:expect/expect.dart';
+
+class A {
+  @pragma('vm:never-inline')
+  double getMaxIntrinsicWidth() => 1.toDouble();
+}
+
+A _leading = A();
+
+@pragma('vm:never-inline')
+double computeMaxIntrinsicWidth(double height, double horizontalPadding) {
+  final leadingWidth =
+      _leading == null ? 0 : _leading.getMaxIntrinsicWidth() as int;
+  return horizontalPadding + leadingWidth;
+}
+
+main() {
+  Expect.throws(() => computeMaxIntrinsicWidth(1, 2));
+}

runtime/tests/vm/dart_2/regress_flutter83094_test.dart

@@ -0,0 +1,27 @@
+// Copyright (c) 2021, 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.
+
+// Verifies that compiler doesn't crash due to incompatible types
+// when unboxing input of a Phi.
+// Regression test for https://github.com/flutter/flutter/issues/83094.
+
+import 'package:expect/expect.dart';
+
+class A {
+  @pragma('vm:never-inline')
+  double getMaxIntrinsicWidth() => 1.toDouble();
+}
+
+A _leading = A();
+
+@pragma('vm:never-inline')
+double computeMaxIntrinsicWidth(double height, double horizontalPadding) {
+  final leadingWidth =
+      _leading == null ? 0 : _leading.getMaxIntrinsicWidth() as int;
+  return horizontalPadding + leadingWidth;
+}
+
+main() {
+  Expect.throws(() => computeMaxIntrinsicWidth(1, 2));
+}

runtime/vm/compiler/backend/flow_graph.cc

@@ -1809,22 +1809,26 @@ void FlowGraph::InsertConversion(Representation from,
                                  Value* use,
                                  bool is_environment_use) {
   Instruction* insert_before;
-  Instruction* deopt_target;
   PhiInstr* phi = use->instruction()->AsPhi();
   if (phi != NULL) {
     ASSERT(phi->is_alive());
     // For phis conversions have to be inserted in the predecessor.
     auto predecessor = phi->block()->PredecessorAt(use->use_index());
     insert_before = predecessor->last_instruction();
     ASSERT(insert_before->GetBlock() == predecessor);
-    deopt_target = NULL;
   } else {
-    deopt_target = insert_before = use->instruction();
+    insert_before = use->instruction();
+  }
+  const Instruction::SpeculativeMode speculative_mode =
+      use->instruction()->SpeculativeModeOfInput(use->use_index());
+  Instruction* deopt_target = nullptr;
+  if (speculative_mode == Instruction::kGuardInputs || to == kUnboxedInt32) {
+    deopt_target = insert_before;
   }
 
   Definition* converted = NULL;
   if (IsUnboxedInteger(from) && IsUnboxedInteger(to)) {
-    const intptr_t deopt_id = (to == kUnboxedInt32) && (deopt_target != NULL)
+    const intptr_t deopt_id = (to == kUnboxedInt32) && (deopt_target != nullptr)
                                   ? deopt_target->DeoptimizationTarget()
                                   : DeoptId::kNone;
     converted =
@@ -1833,49 +1837,50 @@ void FlowGraph::InsertConversion(Representation from,
     converted = new Int32ToDoubleInstr(use->CopyWithType());
   } else if ((from == kUnboxedInt64) && (to == kUnboxedDouble) &&
              CanConvertInt64ToDouble()) {
-    const intptr_t deopt_id = (deopt_target != NULL)
+    const intptr_t deopt_id = (deopt_target != nullptr)
                                   ? deopt_target->DeoptimizationTarget()
                                   : DeoptId::kNone;
     ASSERT(CanUnboxDouble());
     converted = new Int64ToDoubleInstr(use->CopyWithType(), deopt_id);
   } else if ((from == kTagged) && Boxing::Supports(to)) {
-    const intptr_t deopt_id = (deopt_target != NULL)
+    const intptr_t deopt_id = (deopt_target != nullptr)
                                   ? deopt_target->DeoptimizationTarget()
                                   : DeoptId::kNone;
-    converted = UnboxInstr::Create(
-        to, use->CopyWithType(), deopt_id,
-        use->instruction()->SpeculativeModeOfInput(use->use_index()));
+    converted =
+        UnboxInstr::Create(to, use->CopyWithType(), deopt_id, speculative_mode);
   } else if ((to == kTagged) && Boxing::Supports(from)) {
     converted = BoxInstr::Create(from, use->CopyWithType());
   } else {
     // We have failed to find a suitable conversion instruction.
     // Insert two "dummy" conversion instructions with the correct
     // "from" and "to" representation. The inserted instructions will
     // trigger a deoptimization if executed. See #12417 for a discussion.
-    const intptr_t deopt_id = (deopt_target != NULL)
+    // If the use is not speculative, then this code should be unreachable.
+    // Insert Stop for a graceful error and aid unreachable code elimination.
+    if (speculative_mode == Instruction::kNotSpeculative) {
+      StopInstr* stop = new (Z) StopInstr("Incompatible conversion.");
+      InsertBefore(insert_before, stop, nullptr, FlowGraph::kEffect);
+    }
+    const intptr_t deopt_id = (deopt_target != nullptr)
                                   ? deopt_target->DeoptimizationTarget()
                                   : DeoptId::kNone;
     ASSERT(Boxing::Supports(from));
     ASSERT(Boxing::Supports(to));
     Definition* boxed = BoxInstr::Create(from, use->CopyWithType());
     use->BindTo(boxed);
-    InsertBefore(insert_before, boxed, NULL, FlowGraph::kValue);
-    converted = UnboxInstr::Create(to, new (Z) Value(boxed), deopt_id);
+    InsertBefore(insert_before, boxed, nullptr, FlowGraph::kValue);
+    converted = UnboxInstr::Create(to, new (Z) Value(boxed), deopt_id,
+                                   speculative_mode);
   }
-  ASSERT(converted != NULL);
-  InsertBefore(insert_before, converted, use->instruction()->env(),
+  ASSERT(converted != nullptr);
+  InsertBefore(insert_before, converted,
+               (deopt_target != nullptr) ? deopt_target->env() : nullptr,
                FlowGraph::kValue);
   if (is_environment_use) {
     use->BindToEnvironment(converted);
   } else {
     use->BindTo(converted);
   }
-
-  if ((to == kUnboxedInt32) && (phi != NULL)) {
-    // Int32 phis are unboxed optimistically. Ensure that unboxing
-    // has deoptimization target attached from the goto instruction.
-    CopyDeoptTarget(converted, insert_before);
-  }
 }
 
 void FlowGraph::InsertConversionsFor(Definition* def) {

runtime/vm/compiler/backend/il.h

@@ -2481,9 +2481,12 @@ class PhiInstr : public Definition {
 
   virtual void set_representation(Representation r) { representation_ = r; }
 
-  // In AOT mode Phi instructions do not check types of inputs when unboxing.
+  // Only Int32 phis in JIT mode are unboxed optimistically.
   virtual SpeculativeMode SpeculativeModeOfInput(intptr_t index) const {
-    return CompilerState::Current().is_aot() ? kNotSpeculative : kGuardInputs;
+    return (CompilerState::Current().is_aot() ||
+            (representation_ != kUnboxedInt32))
+               ? kNotSpeculative
+               : kGuardInputs;
   }
 
   virtual intptr_t Hashcode() const {
@@ -3140,6 +3143,9 @@ class GotoInstr : public TemplateInstruction<0, NoThrow> {
     return true;
   }
 
+  // May require a deoptimization target for int32 Phi input conversions.
+  virtual intptr_t DeoptimizationTarget() const { return GetDeoptId(); }
+
   virtual bool ComputeCanDeoptimize() const { return false; }
 
   virtual bool HasUnknownSideEffects() const { return false; }
@@ -4104,6 +4110,7 @@ class InstanceCallBaseInstr : public TemplateDartCall<0> {
       }
       idx--;
     }
+    if (interface_target_.IsNull()) return kGuardInputs;
     return interface_target_.is_unboxed_parameter_at(idx) ? kNotSpeculative
                                                           : kGuardInputs;
   }

tools/VERSION

@@ -26,6 +26,6 @@
 CHANNEL stable
 MAJOR 2
 MINOR 13
-PATCH 1
+PATCH 2
 PRERELEASE 0
 PRERELEASE_PATCH 0