[Sema] Rebase and address feedback for implicit member chains

Author: Jumhyn

include/swift/AST/DiagnosticsSema.def

@@ -113,7 +113,8 @@ ERROR(expected_argument_in_contextual_member,none,
 ERROR(expected_parens_in_contextual_member,none,
       "member %0 is a function; did you mean to call it?", (DeclName))
 ERROR(expected_parens_in_contextual_member_type,none,
-      "member %0 is a function that produces expected type %1; did you mean to call it?", (DeclName, Type))
+      "member %0 is a function that produces expected type %1; did you mean to "
+      "call it?", (DeclName, Type))
 
 ERROR(expected_result_in_contextual_member,none,
       "member %0 in %2 produces result of type %1, but context expects %2",
@@ -456,7 +457,8 @@ ERROR(cannot_convert_parent_type,none,
       "cannot convert parent type %0 to expected type %1",
       (Type, Type))
 ERROR(cannot_convert_chain_result_type,none,
-      "member chain produces result of type %0 but contextual base was inferred as %1",
+      "member chain produces result of type %0 but contextual base was "
+      "inferred as %1",
       (Type, Type))
 
 NOTE(generic_argument_mismatch,none,

include/swift/AST/Expr.h

@@ -2094,10 +2094,18 @@ class ParenExpr : public IdentityExpr {
 /// to give the result type of such a chain representation in the AST. This
 /// expression type is always implicit.
 class UnresolvedMemberChainResultExpr : public IdentityExpr {
+  /// The base of this chain of member accesses.
+  UnresolvedMemberExpr *ChainBase;
 public:
-  UnresolvedMemberChainResultExpr(Expr *subExpr, Type ty = Type())
+  UnresolvedMemberChainResultExpr(Expr *subExpr, UnresolvedMemberExpr *base,
+                                  Type ty = Type())
     : IdentityExpr(ExprKind::UnresolvedMemberChainResult, subExpr, ty,
-                   /*isImplicit=*/true) {}
+                   /*isImplicit=*/true),
+      ChainBase(base) {
+    assert(base);
+  }
+
+  UnresolvedMemberExpr *getChainBase() const { return ChainBase; }
 
   SWIFT_FORWARD_SOURCE_LOCS_TO(getSubExpr())
 

lib/Sema/CSApply.cpp

@@ -2757,7 +2757,7 @@ namespace {
       // an ambiguity tolerant mode used for diagnostic generation.  Just leave
       // this as an unresolved member reference.
       Type resultTy = simplifyType(cs.getType(expr));
-      if (resultTy->getRValueType()->is<UnresolvedType>()) {
+      if (resultTy->hasUnresolvedType()) {
         cs.setType(expr, resultTy);
         return expr;
       }

lib/Sema/CSDiagnostics.cpp

@@ -2160,17 +2160,9 @@ bool ContextualFailure::diagnoseAsError() {
 
   case ConstraintLocator::UnresolvedMemberChainResult: {
     auto &solution = getSolution();
-    auto member = anchor;
-    if (auto *CE = getAsExpr<CallExpr>(anchor))
-      member = CE->getFn();
-
-    auto kind = ConstraintLocator::Member;
-    if (isExpr<UnresolvedMemberExpr>(anchor))
-      kind = ConstraintLocator::UnresolvedMember;
-    else if (isExpr<SubscriptExpr>(anchor))
-      kind = ConstraintLocator::SubscriptMember;
-    auto overload = getOverloadChoiceIfAvailable(getConstraintLocator(member,
-                                                                      kind));
+
+    auto overload =
+        getCalleeOverloadChoiceIfAvailable(getConstraintLocator(anchor));
     if (!(overload && overload->choice.isDecl()))
       return false;
 

lib/Sema/CSGen.cpp

@@ -1503,32 +1503,20 @@ namespace {
     Type visitUnresolvedMemberChainResultExpr(
         UnresolvedMemberChainResultExpr *expr) {
       auto *tail = expr->getSubExpr();
-      assert(isa<UnresolvedMemberExpr>(tail) || isa<UnresolvedDotExpr>(tail) ||
-             isa<CallExpr>(tail) || isa<BindOptionalExpr>(tail) ||
-             isa<ForceValueExpr>(tail) ||
-             isa<SubscriptExpr>(tail) &&
-                 "Unexpected expression at end of unresolved member chain");
-
       auto memberTy = CS.getType(tail);
-      auto *base = TypeChecker::getUnresolvedMemberChainBase(tail);
-
-      // FIXME: This is a workaround for SR-13357, should not be necessary.
-      // Copy any type variable options from the result of the tail member to
-      // the result of the entire chain.
-      unsigned additionalOptions = 0;
-      if (auto *tvt = memberTy->getAs<TypeVariableType>())
-        additionalOptions = tvt->getImpl().getRawOptions();
+      auto *base = expr->getChainBase();
+      assert(base == TypeChecker::getUnresolvedMemberChainBase(tail));
 
-      // The contextual type (represented with a new type variable) must equal
-      // the base type.
+      // The result type of the chain is is represented by a new type variable.
       auto locator = CS.getConstraintLocator(
           expr, ConstraintLocator::UnresolvedMemberChainResult);
-      auto tvo = additionalOptions | TVO_CanBindToHole | TVO_CanBindToNoEscape;
-      auto chainResultTy = CS.createTypeVariable(locator, tvo);
-      auto chainBaseTy = UnresolvedBaseTypes.find(base)->second;
+      auto chainResultTy = CS.createTypeVariable(
+          locator,
+          TVO_CanBindToLValue | TVO_CanBindToHole | TVO_CanBindToNoEscape);
+      auto chainBaseTy = getUnresolvedBaseType(base);
 
-      // The result of this element of the chain must be convertible to the
-      // contextual type, and the contextual type must be equal to the base.
+      // The result of the last element of the chain must be convertible to the
+      // whole chain, and the type of the whole chain must be equal to the base.
       CS.addConstraint(
           ConstraintKind::Conversion, memberTy, chainBaseTy,
           CS.getConstraintLocator(tail, ConstraintLocator::RValueAdjustment));
@@ -3828,7 +3816,6 @@ namespace {
       }
 
       if (auto type = CG.visit(expr)) {
-
         auto simplifiedType = CS.simplifyType(type);
 
         CS.setType(expr, simplifiedType);

lib/Sema/ConstraintSystem.cpp

@@ -3860,7 +3860,7 @@ void constraints::simplifyLocator(ASTNode &anchor,
     }
 
     case ConstraintLocator::UnresolvedMemberChainResult: {
-      auto *resultExpr = getAsExpr<UnresolvedMemberChainResultExpr>(anchor);
+      auto *resultExpr = castToExpr<UnresolvedMemberChainResultExpr>(anchor);
       anchor = resultExpr->getSubExpr();
       path = path.slice(1);
       continue;

lib/Sema/TypeCheckConstraints.cpp

@@ -1370,7 +1370,7 @@ namespace {
       if (isMemberChainTail(expr, parent))
         if (auto *UME = TypeChecker::getUnresolvedMemberChainBase(expr))
           if (!parent || !isa<UnresolvedMemberChainResultExpr>(parent))
-            return new (ctx) UnresolvedMemberChainResultExpr(expr);
+            return new (ctx) UnresolvedMemberChainResultExpr(expr, UME);
 
       return expr;
     }

test/expr/delayed-ident/member_chains.swift

@@ -126,8 +126,8 @@ let _: ImplicitMembers = .implicit[optional: ()] // expected-error {{value of op
 let _: ImplicitMembers = .implicit[funcOptional: ()]() // expected-error {{value of optional type 'ImplicitMembers?' must be unwrapped to a value of type 'ImplicitMembers'}} expected-note {{coalesce using '??' to provide a default when the optional value contains 'nil'}} {{55-55= ?? <#default value#>}} expected-note {{force-unwrap using '!' to abort execution if the optional value contains 'nil'}} {{55-55=!}}
 
 // FIXME: Improve these diagnostics (should probably offer unwrapping, as above)
-let _: ImplicitMembers = .implicit.anotherOptional?.another // expected-error{{cannot infer contextual base in reference to member 'implicit'}} expected-error{{cannot convert value of type 'Optional<_>' to specified type 'ImplicitMembers'}}
-let _: ImplicitMembers = .implicit[optionalFunc: ()]?() // expected-error{{cannot infer contextual base in reference to member 'implicit'}} expected-error{{cannot convert value of type 'Optional<_>' to specified type 'ImplicitMembers'}}
+let _: ImplicitMembers = .implicit.anotherOptional?.another // expected-error{{type of expression is ambiguous without more context}}
+let _: ImplicitMembers = .implicit[optionalFunc: ()]?() // expected-error{{type of expression is ambiguous without more context}}
 
 
 let _: ImplicitMembers = .other.implicit