[CSGen] Don't expect implicit casts to have type reprs

Implicit casts are allowed to be constructed with a type, instead
of a type repr. Constraint generation should honor that, and fallback
to using cast type when repr is was not given.

Author: xedin

lib/Sema/CSGen.cpp

@@ -2969,18 +2969,27 @@ namespace {
       return typeVar;
     }
 
+    Type getTypeForCast(ExplicitCastExpr *E) {
+      if (auto *const repr = E->getCastTypeRepr()) {
+        // Validate the resulting type.
+        return resolveTypeReferenceInExpression(
+            repr, TypeResolverContext::ExplicitCastExpr,
+            CS.getConstraintLocator(E));
+      }
+      assert(E->isImplicit());
+      return E->getCastType();
+    }
+
     Type visitForcedCheckedCastExpr(ForcedCheckedCastExpr *expr) {
       auto fromExpr = expr->getSubExpr();
       if (!fromExpr) // Either wasn't constructed correctly or wasn't folded.
         return nullptr;
 
-      auto *const repr = expr->getCastTypeRepr();
-      // Validate the resulting type.
-      const auto toType = resolveTypeReferenceInExpression(
-          repr, TypeResolverContext::ExplicitCastExpr,
-          CS.getConstraintLocator(expr));
+      auto toType = getTypeForCast(expr);
       if (!toType)
-        return nullptr;
+        return Type();
+
+      auto *const repr = expr->getCastTypeRepr();
 
       // Cache the type we're casting to.
       if (repr) CS.setType(repr, toType);
@@ -3001,13 +3010,12 @@ namespace {
 
     Type visitCoerceExpr(CoerceExpr *expr) {
       // Validate the resulting type.
-      auto *const repr = expr->getCastTypeRepr();
-      const auto toType = resolveTypeReferenceInExpression(
-          repr, TypeResolverContext::ExplicitCastExpr,
-          CS.getConstraintLocator(expr));
+      auto toType = getTypeForCast(expr);
       if (!toType)
         return nullptr;
 
+      auto *const repr = expr->getCastTypeRepr();
+
       // Cache the type we're casting to.
       if (repr) CS.setType(repr, toType);
 
@@ -3033,13 +3041,12 @@ namespace {
         return nullptr;
 
       // Validate the resulting type.
-      auto *const repr = expr->getCastTypeRepr();
-      const auto toType = resolveTypeReferenceInExpression(
-          repr, TypeResolverContext::ExplicitCastExpr,
-          CS.getConstraintLocator(expr));
+      const auto toType = getTypeForCast(expr);
       if (!toType)
         return nullptr;
 
+      auto *const repr = expr->getCastTypeRepr();
+
       // Cache the type we're casting to.
       if (repr) CS.setType(repr, toType);
 
@@ -3058,24 +3065,22 @@ namespace {
     }
 
     Type visitIsExpr(IsExpr *expr) {
-      // Validate the type.
-      // FIXME: Locator for the cast type?
-      auto &ctx = CS.getASTContext();
-      const auto toType = resolveTypeReferenceInExpression(
-          expr->getCastTypeRepr(), TypeResolverContext::ExplicitCastExpr,
-          CS.getConstraintLocator(expr));
+      auto toType = getTypeForCast(expr);
       if (!toType)
         return nullptr;
 
+      auto *const repr = expr->getCastTypeRepr();
       // Cache the type we're checking.
-      CS.setType(expr->getCastTypeRepr(), toType);
+      if (repr)
+        CS.setType(repr, toType);
 
       // Add a checked cast constraint.
       auto fromType = CS.getType(expr->getSubExpr());
 
       CS.addConstraint(ConstraintKind::CheckedCast, fromType, toType,
                        CS.getConstraintLocator(expr));
 
+      auto &ctx = CS.getASTContext();
       // The result is Bool.
       auto boolDecl = ctx.getBoolDecl();
 

unittests/Sema/CMakeLists.txt

@@ -2,6 +2,7 @@
 add_swift_unittest(swiftSemaTests
   SemaFixture.cpp
   BindingInferenceTests.cpp
+  ConstraintGenerationTests.cpp
   ConstraintSimplificationTests.cpp
   UnresolvedMemberLookupTests.cpp
   PlaceholderTypeInferenceTests.cpp

unittests/Sema/ConstraintGenerationTests.cpp

@@ -0,0 +1,88 @@
+//===--- ConstraintGenerationTests.cpp ------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 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/AST/Expr.h"
+
+using namespace swift;
+using namespace swift::unittest;
+using namespace swift::constraints;
+
+TEST_F(SemaTest, TestImplicitForceCastConstraintGeneration) {
+  ConstraintSystem cs(DC, ConstraintSystemOptions());
+
+  auto *literal = IntegerLiteralExpr::createFromUnsigned(Context, 42);
+
+  auto *cast = ForcedCheckedCastExpr::createImplicit(Context, literal,
+                                                     getStdlibType("Double"));
+
+  auto *expr = cs.generateConstraints(cast, DC, /*isInputExpression=*/true);
+
+  ASSERT_NE(expr, nullptr);
+
+  SmallVector<Solution, 2> solutions;
+  cs.solve(solutions);
+
+  ASSERT_EQ(solutions.size(), (unsigned)1);
+
+  auto &solution = solutions.front();
+
+  ASSERT_TRUE(solution.getResolvedType(literal)->isEqual(getStdlibType("Int")));
+  ASSERT_TRUE(solution.getResolvedType(cast)->isEqual(getStdlibType("Double")));
+}
+
+TEST_F(SemaTest, TestImplicitCoercionConstraintGeneration) {
+  ConstraintSystem cs(DC, ConstraintSystemOptions());
+
+  auto *literal = IntegerLiteralExpr::createFromUnsigned(Context, 42);
+
+  auto *cast = CoerceExpr::createImplicit(Context, literal,
+                                          getStdlibType("Double"));
+
+  auto *expr = cs.generateConstraints(cast, DC, /*isInputExpression=*/true);
+
+  ASSERT_NE(expr, nullptr);
+
+  SmallVector<Solution, 2> solutions;
+  cs.solve(solutions);
+
+  ASSERT_EQ(solutions.size(), (unsigned)1);
+
+  auto &solution = solutions.front();
+
+  ASSERT_TRUE(solution.getResolvedType(literal)->isEqual(getStdlibType("Double")));
+  ASSERT_TRUE(solution.getResolvedType(cast)->isEqual(getStdlibType("Double")));
+}
+
+TEST_F(SemaTest, TestImplicitConditionalCastConstraintGeneration) {
+  ConstraintSystem cs(DC, ConstraintSystemOptions());
+
+  auto *literal = IntegerLiteralExpr::createFromUnsigned(Context, 42);
+
+  auto *cast = ConditionalCheckedCastExpr::createImplicit(
+      Context, literal, getStdlibType("Double"));
+
+  auto *expr = cs.generateConstraints(cast, DC, /*isInputExpression=*/true);
+
+  ASSERT_NE(expr, nullptr);
+
+  SmallVector<Solution, 2> solutions;
+  cs.solve(solutions);
+
+  ASSERT_EQ(solutions.size(), (unsigned)1);
+
+  auto &solution = solutions.front();
+
+  ASSERT_TRUE(solution.getResolvedType(literal)->isEqual(getStdlibType("Int")));
+  ASSERT_TRUE(solution.getResolvedType(cast)->isEqual(
+      OptionalType::get(getStdlibType("Double"))));
+}