Merge pull request swiftlang#39412 from Jumhyn/sr-15192

xedin · web-flow · commit 88ad3b79554d · 2021-10-05T09:45:24.000-07:00
Replace inferrable types before binding literals to contextual type
diff --git a/include/swift/Sema/ConstraintSystem.h b/include/swift/Sema/ConstraintSystem.h
@@ -908,6 +908,7 @@ using OpenedTypeMap =
 /// within a constraint system.
 struct ContextualTypeInfo {
   TypeLoc typeLoc;
+
   ContextualTypePurpose purpose;
 
   ContextualTypeInfo() : typeLoc(TypeLoc()), purpose(CTP_Unused) {}
@@ -2343,8 +2344,10 @@ class ConstraintSystem {
     solutionApplicationTargets;
 
   /// Contextual type information for expressions that are part of this
-  /// constraint system.
-  llvm::MapVector<ASTNode, ContextualTypeInfo> contextualTypes;
+  /// constraint system. The second type, if valid, contains the type as it
+  /// should appear in actual constraint. This will have unbound generic types
+  /// opened, placeholder types converted to type variables, etc.
+  llvm::MapVector<ASTNode, std::pair<ContextualTypeInfo, Type>> contextualTypes;
 
   /// Information about each case label item tracked by the constraint system.
   llvm::SmallMapVector<const CaseLabelItem *, CaseLabelItemInfo, 4>
@@ -3184,21 +3187,47 @@ class ConstraintSystem {
     assert(bool(node) && "Expected non-null expression!");
     assert(contextualTypes.count(node) == 0 &&
            "Already set this contextual type");
-    contextualTypes[node] = {T, purpose};
+    contextualTypes[node] = {{T, purpose}, Type()};
   }
 
   Optional<ContextualTypeInfo> getContextualTypeInfo(ASTNode node) const {
     auto known = contextualTypes.find(node);
     if (known == contextualTypes.end())
       return None;
-    return known->second;
-  }
-
-  Type getContextualType(ASTNode node) const {
-    auto result = getContextualTypeInfo(node);
-    if (result)
-      return result->typeLoc.getType();
-    return Type();
+    return known->second.first;
+  }
+
+  /// Gets the contextual type recorded for an AST node. When fetching a type
+  /// for use in constraint solving, \c forConstraint should be set to \c true,
+  /// which will ensure that unbound generics have been opened and placeholder
+  /// types have been converted to type variables, etc.
+  Type getContextualType(ASTNode node, bool forConstraint = false) {
+    if (forConstraint) {
+      auto known = contextualTypes.find(node);
+      if (known == contextualTypes.end())
+        return Type();
+
+      // If we've already computed a type for use in the constraint system,
+      // use that.
+      if (known->second.second)
+        return known->second.second;
+
+      // Otherwise, compute a type that can be used in a constraint and record
+      // it.
+      auto info = known->second.first;
+
+      auto *locator = getConstraintLocator(
+          node, LocatorPathElt::ContextualType(info.purpose));
+      known->second.second = replaceInferableTypesWithTypeVars(info.getType(),
+                                                               locator);
+
+      return known->second.second;
+    } else {
+      auto result = getContextualTypeInfo(node);
+      if (result)
+        return result->getType();
+      return Type();
+    }
   }
 
   TypeLoc getContextualTypeLoc(ASTNode node) const {
diff --git a/lib/Sema/CSGen.cpp b/lib/Sema/CSGen.cpp
@@ -1731,9 +1731,12 @@ namespace {
       };
 
       // If a contextual type exists for this expression, apply it directly.
-      Optional<Type> arrayElementType;
-      if (contextualType &&
-          (arrayElementType = ConstraintSystem::isArrayType(contextualType))) {
+      if (contextualType && ConstraintSystem::isArrayType(contextualType)) {
+        // Now that we know we're actually going to use the type, get the
+        // version for use in a constraint.
+        contextualType = CS.getContextualType(expr, /*forConstraint=*/true);
+        Optional<Type> arrayElementType =
+            ConstraintSystem::isArrayType(contextualType);
         CS.addConstraint(ConstraintKind::LiteralConformsTo, contextualType,
                          arrayProto->getDeclaredInterfaceType(),
                          locator);
@@ -1836,14 +1839,19 @@ namespace {
       auto locator = CS.getConstraintLocator(expr);
       auto contextualType = CS.getContextualType(expr);
       auto contextualPurpose = CS.getContextualTypePurpose(expr);
-      auto openedType =
-          CS.openOpaqueType(contextualType, contextualPurpose, locator);
 
       // If a contextual type exists for this expression and is a dictionary
       // type, apply it directly.
-      Optional<std::pair<Type, Type>> dictionaryKeyValue;
-      if (openedType && (dictionaryKeyValue =
-                             ConstraintSystem::isDictionaryType(openedType))) {
+      if (contextualType && ConstraintSystem::isDictionaryType(contextualType)) {
+        // Now that we know we're actually going to use the type, get the
+        // version for use in a constraint.
+        contextualType = CS.getContextualType(expr, /*forConstraint=*/true);
+        auto openedType =
+            CS.openOpaqueType(contextualType, contextualPurpose, locator);
+        openedType = CS.replaceInferableTypesWithTypeVars(
+            openedType, CS.getConstraintLocator(expr));
+        auto dictionaryKeyValue =
+            ConstraintSystem::isDictionaryType(openedType);
         Type contextualDictionaryKeyType;
         Type contextualDictionaryValueType;
         std::tie(contextualDictionaryKeyType,
diff --git a/lib/Sema/CSSolver.cpp b/lib/Sema/CSSolver.cpp
@@ -180,8 +180,9 @@ Solution ConstraintSystem::finalize() {
   }
 
   // Remember contextual types.
-  solution.contextualTypes.assign(
-      contextualTypes.begin(), contextualTypes.end());
+  for (auto &entry : contextualTypes) {
+    solution.contextualTypes.push_back({entry.first, entry.second.first});
+  }
 
   solution.solutionApplicationTargets = solutionApplicationTargets;
   solution.caseLabelItems = caseLabelItems;
diff --git a/lib/Sema/TypeCheckConstraints.cpp b/lib/Sema/TypeCheckConstraints.cpp
@@ -1116,9 +1116,10 @@ void ConstraintSystem::print(raw_ostream &out) const {
   
   out << "Score: " << CurrentScore << "\n";
 
-  for (const auto &contextualType : contextualTypes) {
-    out << "Contextual Type: " << contextualType.second.getType().getString(PO);
-    if (TypeRepr *TR = contextualType.second.typeLoc.getTypeRepr()) {
+  for (const auto &contextualTypeEntry : contextualTypes) {
+    auto info = contextualTypeEntry.second.first;
+    out << "Contextual Type: " << info.getType().getString(PO);
+    if (TypeRepr *TR = info.typeLoc.getTypeRepr()) {
       out << " at ";
       TR->getSourceRange().print(out, getASTContext().SourceMgr, /*text*/false);
     }
diff --git a/unittests/Sema/CMakeLists.txt b/unittests/Sema/CMakeLists.txt
@@ -3,7 +3,8 @@ add_swift_unittest(swiftSemaTests
   SemaFixture.cpp
   BindingInferenceTests.cpp
   ConstraintSimplificationTests.cpp
-  UnresolvedMemberLookupTests.cpp)
+  UnresolvedMemberLookupTests.cpp
+  PlaceholderTypeInferenceTests.cpp)
 
 target_link_libraries(swiftSemaTests
   PRIVATE
diff --git a/unittests/Sema/PlaceholderTypeInferenceTests.cpp b/unittests/Sema/PlaceholderTypeInferenceTests.cpp
@@ -0,0 +1,98 @@
+//===--- PlaceholderTypeInferenceTests.cpp --------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 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, TestPlaceholderInferenceForArrayLiteral) {
+  auto *intTypeDecl = getStdlibNominalTypeDecl("Int");
+
+  auto *intLiteral = new (Context) IntegerLiteralExpr("0", SourceLoc(), true);
+  auto *arrayExpr = ArrayExpr::create(Context, SourceLoc(), {intLiteral}, {}, SourceLoc());
+
+  auto *placeholderRepr = new (Context) PlaceholderTypeRepr(SourceLoc());
+  auto *arrayRepr = new (Context) ArrayTypeRepr(placeholderRepr, SourceRange());
+  auto placeholderTy = PlaceholderType::get(Context, placeholderRepr);
+  auto *arrayTy = ArraySliceType::get(placeholderTy);
+
+  auto *varDecl = new (Context) VarDecl(false, VarDecl::Introducer::Let, SourceLoc(), Context.getIdentifier("x"), DC);
+  auto *namedPattern = new (Context) NamedPattern(varDecl);
+  auto *typedPattern = new (Context) TypedPattern(namedPattern, arrayRepr);
+
+  auto target = SolutionApplicationTarget::forInitialization(arrayExpr, DC, arrayTy, typedPattern, /*bindPatternVarsOneWay=*/false);
+
+  ConstraintSystem cs(DC, ConstraintSystemOptions());
+  cs.setContextualType(arrayExpr, {arrayRepr, arrayTy}, CTP_Initialization);
+  cs.generateConstraints(target, FreeTypeVariableBinding::Disallow);
+  SmallVector<Solution, 2> solutions;
+  cs.solve(solutions);
+
+  // We should have a solution.
+  ASSERT_EQ(solutions.size(), 1u);
+
+  auto &solution = solutions[0];
+
+  auto eltTy = ConstraintSystem::isArrayType(solution.simplifyType(solution.getType(arrayExpr)));
+  ASSERT_TRUE(eltTy.hasValue());
+  ASSERT_TRUE((*eltTy)->is<StructType>());
+  ASSERT_EQ((*eltTy)->getAs<StructType>()->getDecl(), intTypeDecl);
+}
+
+TEST_F(SemaTest, TestPlaceholderInferenceForDictionaryLiteral) {
+  auto *intTypeDecl = getStdlibNominalTypeDecl("Int");
+  auto *stringTypeDecl = getStdlibNominalTypeDecl("String");
+
+  auto *intLiteral = new (Context) IntegerLiteralExpr("0", SourceLoc(), true);
+  auto *stringLiteral = new (Context) StringLiteralExpr("test", SourceRange(), true);
+  auto *kvTupleExpr = TupleExpr::create(Context, SourceLoc(), {stringLiteral, intLiteral}, {}, {}, SourceLoc(), true);
+  auto *dictExpr = DictionaryExpr::create(Context, SourceLoc(), {kvTupleExpr}, {}, SourceLoc());
+
+  auto *keyPlaceholderRepr = new (Context) PlaceholderTypeRepr(SourceLoc());
+  auto *valPlaceholderRepr = new (Context) PlaceholderTypeRepr(SourceLoc());
+  auto *dictRepr = new (Context) DictionaryTypeRepr(keyPlaceholderRepr, valPlaceholderRepr, SourceLoc(), SourceRange());
+  auto keyPlaceholderTy = PlaceholderType::get(Context, keyPlaceholderRepr);
+  auto valPlaceholderTy = PlaceholderType::get(Context, valPlaceholderRepr);
+  auto *dictTy = DictionaryType::get(keyPlaceholderTy, valPlaceholderTy);
+
+  auto *varDecl = new (Context) VarDecl(false, VarDecl::Introducer::Let, SourceLoc(), Context.getIdentifier("x"), DC);
+  auto *namedPattern = new (Context) NamedPattern(varDecl);
+  auto *typedPattern = new (Context) TypedPattern(namedPattern, dictRepr);
+
+  auto target = SolutionApplicationTarget::forInitialization(dictExpr, DC, dictTy, typedPattern, /*bindPatternVarsOneWay=*/false);
+
+  ConstraintSystem cs(DC, ConstraintSystemOptions());
+  cs.setContextualType(dictExpr, {dictRepr, dictTy}, CTP_Initialization);
+  cs.generateConstraints(target, FreeTypeVariableBinding::Disallow);
+  SmallVector<Solution, 2> solutions;
+  cs.solve(solutions);
+
+  // We should have a solution.
+  ASSERT_EQ(solutions.size(), 1u);
+
+  auto &solution = solutions[0];
+
+  auto keyValTys = ConstraintSystem::isDictionaryType(solution.simplifyType(solution.getType(dictExpr)));
+  ASSERT_TRUE(keyValTys.hasValue());
+
+  Type keyTy;
+  Type valTy;
+  std::tie(keyTy, valTy) = *keyValTys;
+  ASSERT_TRUE(keyTy->is<StructType>());
+  ASSERT_EQ(keyTy->getAs<StructType>()->getDecl(), stringTypeDecl);
+
+  ASSERT_TRUE(valTy->is<StructType>());
+  ASSERT_EQ(valTy->getAs<StructType>()->getDecl(), intTypeDecl);
+}
