Merge pull request swiftlang#9129 from CodaFi/heyting-arithmetic-by-any-other-name

Author: swift-ci

include/swift/AST/DiagnosticsSema.def

@@ -908,6 +908,9 @@ ERROR(extra_trailing_closure_in_call,none,
 ERROR(no_accessible_initializers,none,
       "%0 cannot be constructed because it has no accessible initializers",
       (Type))
+ERROR(non_nominal_no_initializers,none,
+      "non-nominal type %0 does not support explicit initialization",
+      (Type))
 ERROR(unbound_generic_parameter,none,
       "generic parameter %0 could not be inferred", (Type))
 ERROR(unbound_generic_parameter_cast,none,

lib/Sema/CSDiag.cpp

@@ -5279,15 +5279,25 @@ static bool diagnoseSingleCandidateFailures(CalleeCandidateInfo &CCI,
 bool FailureDiagnosis::diagnoseParameterErrors(CalleeCandidateInfo &CCI,
                                                Expr *fnExpr, Expr *argExpr,
                                                ArrayRef<Identifier> argLabels) {
-  // If we are invoking a constructor and there are absolutely no candidates,
-  // then they must all be private.
   if (auto *MTT = fnExpr->getType()->getAs<MetatypeType>()) {
-    if (!MTT->getInstanceType()->is<TupleType>() &&
-        (CCI.size() == 0 ||
-         (CCI.size() == 1 && CCI.candidates[0].getDecl() &&
-          isa<ProtocolDecl>(CCI.candidates[0].getDecl())))) {
-      CS->TC.diagnose(fnExpr->getLoc(), diag::no_accessible_initializers,
-                      MTT->getInstanceType());
+    auto instTy = MTT->getInstanceType();
+    if (instTy->getAnyNominal()) {
+      // If we are invoking a constructor on a nominal type and there are
+      // absolutely no candidates, then they must all be private.
+      if (CCI.size() == 0 || (CCI.size() == 1 && CCI.candidates[0].getDecl() &&
+                              isa<ProtocolDecl>(CCI.candidates[0].getDecl()))) {
+        CS->TC.diagnose(fnExpr->getLoc(), diag::no_accessible_initializers,
+                        instTy);
+        return true;
+      }
+      // continue below
+    } else if (!instTy->is<TupleType>()) {
+      // If we are invoking a constructor on a non-nominal type, the expression
+      // is malformed.
+      SourceRange initExprRange(fnExpr->getSourceRange().Start,
+                                argExpr->getSourceRange().End);
+      CS->TC.diagnose(fnExpr->getLoc(), diag::non_nominal_no_initializers,
+                      instTy).highlight(initExprRange);
       return true;
     }
   }

test/decl/init/nonnominal_init.swift

@@ -0,0 +1,16 @@
+// RUN: %target-typecheck-verify-swift
+
+typealias Not<A> = (A) -> Never
+typealias And<A, B> = (left: A, right: B)
+indirect enum Or<A, B> {
+  case inl(A)
+  case inr(B)
+}
+
+func deMorgan<A, B>(_ ne: Not<Or<A, B>>) -> And<Not<A>, Not<B>> {
+  return And<Not<A>, Not<B>>(
+    Not<A> { a in ne(.left(a)) }, // expected-error {{non-nominal type '(A) -> Never' does not support explicit initialization}}
+    Not<B> { a in ne(.right(a)) }
+  )
+}
+