[CS] Add Solution::getTargetFor

Author: hamishknight

include/swift/Sema/ConstraintSystem.h

@@ -1629,6 +1629,14 @@ class Solution {
     return None;
   }
 
+  Optional<SyntacticElementTarget>
+  getTargetFor(SyntacticElementTargetKey key) const {
+    auto known = targets.find(key);
+    if (known == targets.end())
+      return None;
+    return known->second;
+  }
+
   ConstraintLocator *getCalleeLocator(ConstraintLocator *locator,
                                       bool lookThroughApply = true) const;
 

lib/IDE/ArgumentCompletion.cpp

@@ -95,19 +95,18 @@ static bool isExpressionResultTypeUnconstrained(const Solution &S, Expr *E) {
       return true;
     }
   }
-  auto targetIt = S.targets.find(E);
-  if (targetIt == S.targets.end()) {
+  auto target = S.getTargetFor(E);
+  if (!target)
     return false;
-  }
-  auto target = targetIt->second;
-  assert(target.kind == SyntacticElementTarget::Kind::expression);
-  switch (target.getExprContextualTypePurpose()) {
+
+  assert(target->kind == SyntacticElementTarget::Kind::expression);
+  switch (target->getExprContextualTypePurpose()) {
   case CTP_Unused:
     // If we aren't using the contextual type, its unconstrained by definition.
     return true;
   case CTP_Initialization: {
     // let x = <expr> is unconstrained
-    auto contextualType = target.getExprContextualType();
+    auto contextualType = target->getExprContextualType();
     return !contextualType || contextualType->is<UnresolvedType>();
   }
   default:

lib/IDE/PostfixCompletion.cpp

@@ -52,11 +52,9 @@ getClosureActorIsolation(const Solution &S, AbstractClosureExpr *ACE) {
     // the contextual type might have a global actor attribute but because no
     // methods from that global actor are called in the closure, the closure has
     // a non-actor type.
-    auto target = S.targets.find(dyn_cast<ClosureExpr>(E));
-    if (target != S.targets.end()) {
-      if (auto Ty = target->second.getClosureContextualType()) {
+    if (auto target = S.getTargetFor(dyn_cast<ClosureExpr>(E))) {
+      if (auto Ty = target->getClosureContextualType())
         return Ty;
-      }
     }
     if (!S.hasType(E)) {
       return Type();

lib/IDE/TypeCheckCompletionCallback.cpp

@@ -165,9 +165,8 @@ bool swift::ide::isContextAsync(const constraints::Solution &S,
   //    closure that doesn't contain any async calles. Thus the closure is
   //    type-checked as non-async, but it might get converted to an async
   //    closure based on its contextual type
-  auto target = S.targets.find(dyn_cast<ClosureExpr>(DC));
-  if (target != S.targets.end()) {
-    if (auto ContextTy = target->second.getClosureContextualType()) {
+  if (auto target = S.getTargetFor(dyn_cast<ClosureExpr>(DC))) {
+    if (auto ContextTy = target->getClosureContextualType()) {
       if (auto ContextFuncTy =
               S.simplifyType(ContextTy)->getAs<AnyFunctionType>()) {
         return ContextFuncTy->isAsync();