[Unit tests] Add unit tests for optional lookup behavior

Author: Jumhyn

unittests/Sema/CMakeLists.txt

@@ -2,7 +2,8 @@
 add_swift_unittest(swiftSemaTests
   SemaFixture.cpp
   BindingInferenceTests.cpp
-  ConstraintSimplificationTests.cpp)
+  ConstraintSimplificationTests.cpp
+  UnresolvedMemberLookupTests.cpp)
 
 target_link_libraries(swiftSemaTests
   PRIVATE

unittests/Sema/SemaFixture.cpp

@@ -76,6 +76,39 @@ Type SemaTest::getStdlibType(StringRef name) const {
   return Type();
 }
 
+NominalTypeDecl *SemaTest::getStdlibNominalTypeDecl(StringRef name) const {
+  auto typeName = Context.getIdentifier(name);
+
+  auto *stdlib = Context.getStdlibModule();
+
+  llvm::SmallVector<ValueDecl *, 4> results;
+  stdlib->lookupValue(typeName, NLKind::UnqualifiedLookup, results);
+
+  if (results.size() != 1)
+    return nullptr;
+
+  return dyn_cast<NominalTypeDecl>(results.front());
+}
+
+VarDecl *SemaTest::addExtensionVarMember(NominalTypeDecl *decl,
+                                         StringRef name, Type type) const {
+  auto *ext = ExtensionDecl::create(Context, SourceLoc(), nullptr, { }, DC,
+                                    nullptr);
+  decl->addExtension(ext);
+  ext->setExtendedNominal(decl);
+
+  auto *VD = new (Context) VarDecl(/*isStatic=*/ true, VarDecl::Introducer::Var,
+                                   /*nameLoc=*/ SourceLoc(),
+                                   Context.getIdentifier(name), ext);
+
+  ext->addMember(VD);
+  auto *pat = new (Context) NamedPattern(VD);
+  VD->setNamingPattern(pat);
+  pat->setType(type);
+
+  return VD;
+}
+
 ProtocolType *SemaTest::createProtocol(llvm::StringRef protocolName,
                                        Type parent) {
   auto *PD = new (Context)

unittests/Sema/SemaFixture.h

@@ -67,6 +67,11 @@ class SemaTest : public SemaTestBase {
 protected:
   Type getStdlibType(StringRef name) const;
 
+  NominalTypeDecl *getStdlibNominalTypeDecl(StringRef name) const;
+
+  VarDecl *addExtensionVarMember(NominalTypeDecl *decl, StringRef name,
+                                 Type type) const;
+
   ProtocolType *createProtocol(llvm::StringRef protocolName,
                                Type parent = Type());
 

unittests/Sema/UnresolvedMemberLookupTests.cpp

@@ -0,0 +1,90 @@
+//===--- UnresolvedMemberLookupTests.cpp --------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "SemaFixture.h"
+#include "swift/Sema/ConstraintSystem.h"
+
+using namespace swift;
+using namespace swift::unittest;
+using namespace swift::constraints;
+
+TEST_F(SemaTest, TestLookupAlwaysLooksThroughOptionalBase) {
+  auto *intTypeDecl = getStdlibNominalTypeDecl("Int");
+  auto *optTypeDecl = getStdlibNominalTypeDecl("Optional");
+  auto intType = intTypeDecl->getDeclaredType();
+  auto intOptType = OptionalType::get(intType);
+  auto stringType = getStdlibType("String");
+
+  auto *intMember = addExtensionVarMember(intTypeDecl, "test", intOptType);
+  addExtensionVarMember(optTypeDecl, "test", stringType);
+
+  auto *UME = new (Context)
+      UnresolvedMemberExpr(SourceLoc(), DeclNameLoc(),
+                           DeclNameRef(Context.getIdentifier("test")), true);
+  auto *UMCRE = new (Context) UnresolvedMemberChainResultExpr(UME, UME);
+
+  ConstraintSystem cs(DC, ConstraintSystemOptions());
+  cs.generateConstraints(UMCRE, DC);
+  cs.addConstraint(
+      ConstraintKind::Conversion, cs.getType(UMCRE), intOptType,
+      cs.getConstraintLocator(UMCRE, ConstraintLocator::ContextualType));
+  SmallVector<Solution, 2> solutions;
+  cs.solve(solutions);
+
+  // We should have a solution.
+  ASSERT_EQ(solutions.size(), 1);
+
+  auto &solution = solutions[0];
+  auto *locator = cs.getConstraintLocator(UME,
+                                          ConstraintLocator::UnresolvedMember);
+  auto choice = solution.getOverloadChoice(locator).choice;
+
+  // The `test` member on `Int` should be selected.
+  ASSERT_EQ(choice.getDecl(), intMember);
+}
+
+TEST_F(SemaTest, TestLookupPrefersResultsOnOptionalRatherThanBase) {
+  auto *intTypeDecl = getStdlibNominalTypeDecl("Int");
+  auto *optTypeDecl = getStdlibNominalTypeDecl("Optional");
+  auto intType = intTypeDecl->getDeclaredType();
+  auto intOptType = OptionalType::get(intType);
+
+  addExtensionVarMember(intTypeDecl, "test", intOptType);
+  auto *optMember = addExtensionVarMember(optTypeDecl, "test", intType);
+
+  auto *UME = new (Context)
+      UnresolvedMemberExpr(SourceLoc(), DeclNameLoc(),
+                           DeclNameRef(Context.getIdentifier("test")), true);
+  auto *UMCRE = new (Context) UnresolvedMemberChainResultExpr(UME, UME);
+
+  ConstraintSystem cs(DC, ConstraintSystemOptions());
+  cs.generateConstraints(UMCRE, DC);
+  cs.addConstraint(
+      ConstraintKind::Conversion, cs.getType(UMCRE), intOptType,
+      cs.getConstraintLocator(UMCRE, ConstraintLocator::ContextualType));
+  SmallVector<Solution, 2> solutions;
+  cs.solve(solutions);
+
+  // We should have a solution.
+  ASSERT_EQ(solutions.size(), 1);
+
+  auto &solution = solutions[0];
+  auto *locator = cs.getConstraintLocator(UME,
+                                          ConstraintLocator::UnresolvedMember);
+  auto choice = solution.getOverloadChoice(locator).choice;
+  auto score = solution.getFixedScore();
+
+  // The `test` member on `Optional` should be chosen over the member on `Int`,
+  // even though the score is otherwise worse.
+  ASSERT_EQ(score.Data[SK_ValueToOptional], 1);
+  ASSERT_EQ(choice.getDecl(), optMember);
+}