[Sema] Adjust Diagnostics/IDE to not assume that parameters always have types

Author: xedin

lib/AST/Decl.cpp

@@ -2139,8 +2139,10 @@ Type ValueDecl::getInterfaceType() const {
 }
 
 void ValueDecl::setInterfaceType(Type type) {
-  if (!type.isNull() && isa<ParamDecl>(this)) {
-    assert(!type->is<InOutType>() && "caller did not pass a base type");
+  if (!type.isNull()) {
+    assert(!type->hasTypeVariable() && "Type variable in interface type");
+    if (isa<ParamDecl>(this))
+      assert(!type->is<InOutType>() && "caller did not pass a base type");
   }
   // lldb creates global typealiases with archetypes in them.
   // FIXME: Add an isDebugAlias() flag, like isDebugVar().
@@ -2153,9 +2155,8 @@ void ValueDecl::setInterfaceType(Type type) {
         isa<AbstractClosureExpr>(getDeclContext()))) {
     assert(!type->hasArchetype() &&
            "Archetype in interface type");
-    assert(!type->hasTypeVariable() &&
-           "Archetype in interface type");
   }
+
   TypeAndAccess.setPointer(type);
 }
 

lib/IDE/CodeCompletion.cpp

@@ -2019,6 +2019,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     auto *GenericSig = VD->getInnermostDeclContext()
         ->getGenericSignatureOfContext();
 
+    assert(VD->hasValidSignature());
     Type T = VD->getInterfaceType();
 
     if (*ExprType) {
@@ -2105,6 +2106,10 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     addLeadingDot(Builder);
     Builder.addTextChunk(Name);
     setClangDeclKeywords(VD, Pairs, Builder);
+
+    if (!VD->hasValidSignature())
+      return;
+
     // Add a type annotation.
     Type VarType = getTypeOfMember(VD);
     if (VD->getName() != Ctx.Id_self && VD->isInOut()) {

lib/Sema/CSDiag.cpp

@@ -2479,11 +2479,11 @@ typeCheckArbitrarySubExprIndependently(Expr *subExpr, TCCOptions options) {
     // none of its arguments are type variables.  If so, these type variables
     // would be accessible to name lookup of the subexpression and may thus leak
     // in.  Reset them to UnresolvedTypes for safe measures.
-    for (auto param : *CE->getParameters()) {
-      auto VD = param;
-      if (VD->getType()->hasTypeVariable() || VD->getType()->hasError()) {
-        VD->setType(CS.getASTContext().TheUnresolvedType);
-        VD->setInterfaceType(VD->getType());
+    for (auto *param : *CE->getParameters()) {
+      if (param->hasValidSignature()) {
+        auto type = param->getType();
+        assert(!type->hasTypeVariable() && !type->hasError());
+        (void)type;
       }
     }
   }
@@ -8647,7 +8647,8 @@ diagnoseAmbiguousMultiStatementClosure(ClosureExpr *closure) {
       resultExpr->forEachChildExpr([&](Expr *childExpr) -> Expr *{
         if (auto DRE = dyn_cast<DeclRefExpr>(childExpr)) {
           if (auto param = dyn_cast<ParamDecl>(DRE->getDecl())) {
-            auto paramType = param->hasType() ? param->getType() : Type();
+            auto paramType =
+                param->hasValidSignature() ? param->getType() : Type();
             if (!paramType || paramType->hasTypeVariable()) {
               hasUnresolvedParams = true;
               return nullptr;

lib/Sema/CSGen.cpp

@@ -1341,30 +1341,45 @@ namespace {
         }
       }
 
+      // If we're referring to an invalid declaration, don't type-check.
+      //
+      // FIXME: If the decl is in error, we get no information from this.
+      // We may, alternatively, want to use a type variable in that case,
+      // and possibly infer the type of the variable that way.
+      CS.getTypeChecker().validateDecl(E->getDecl());
+      if (E->getDecl()->isInvalid()) {
+        CS.setType(E, E->getDecl()->getInterfaceType());
+        return nullptr;
+      }
+
+      auto locator = CS.getConstraintLocator(E);
+
       if (auto *param = dyn_cast<ParamDecl>(E->getDecl())) {
-        if (param->hasInterfaceType()) {
-          auto type = param->getInterfaceType();
-          if (type->hasTypeParameter())
-            type = param->getDeclContext()->mapTypeIntoContext(type);
+        // This can only happen when failure diangostics is trying
+        // to type-check expressions inside of a single-statement
+        // closure which refer to anonymous parameters, in this case
+        // let's either use type as written or allocate a fresh type
+        // variable, just like we do for closure type.
+        if (!CS.hasType(param)) {
+          Type paramType;
+          if (param->hasInterfaceType()) {
+            paramType = param->getInterfaceType();
+            if (paramType->hasTypeParameter())
+              paramType =
+                  param->getDeclContext()->mapTypeIntoContext(paramType);
+
+            if (paramType->hasUnboundGenericType())
+              paramType = CS.openUnboundGenericType(paramType, locator);
+
+            CS.setFavoredType(E, paramType.getPointer());
+          } else {
+            paramType = CS.createTypeVariable(locator, TVO_CanBindToLValue);
+          }
 
-          CS.setType(param, type);
-          CS.setFavoredType(E, type.getPointer());
-        }
-      } else {
-        // If we're referring to an invalid declaration, don't type-check.
-        //
-        // FIXME: If the decl is in error, we get no information from this.
-        // We may, alternatively, want to use a type variable in that case,
-        // and possibly infer the type of the variable that way.
-        CS.getTypeChecker().validateDecl(E->getDecl());
-        if (E->getDecl()->isInvalid()) {
-          CS.setType(E, E->getDecl()->getInterfaceType());
-          return nullptr;
+          CS.setType(param, paramType);
         }
       }
 
-      auto locator = CS.getConstraintLocator(E);
-      
       // Create an overload choice referencing this declaration and immediately
       // resolve it. This records the overload for use later.
       auto tv = CS.createTypeVariable(locator,

lib/Sema/CalleeCandidateInfo.cpp

@@ -58,10 +58,13 @@ static bool isSubstitutableFor(Type type, ArchetypeType *archetype,
 
 UncurriedCandidate::UncurriedCandidate(ValueDecl *decl, unsigned level)
 : declOrExpr(decl), level(level), substituted(false) {
-  
-  if (auto *PD = dyn_cast<ParamDecl>(decl))
-    entityType = PD->getType();
-  else {
+
+  if (auto *PD = dyn_cast<ParamDecl>(decl)) {
+    if (PD->hasValidSignature())
+      entityType = PD->getType();
+    else
+      entityType = PD->getASTContext().TheUnresolvedType;
+  } else {
     entityType = decl->getInterfaceType();
     auto *DC = decl->getInnermostDeclContext();
     if (auto *GFT = entityType->getAs<GenericFunctionType>()) {

lib/Sema/TypeCheckDecl.cpp

@@ -3976,7 +3976,7 @@ void TypeChecker::validateDecl(ValueDecl *D) {
     }
 
     auto type = PD->getInterfaceType();
-    if (type->hasError() || type->hasUnresolvedType())
+    if (type->hasError())
       PD->markInvalid();
     break;
   }