[CSDiagnostics] Add diagnostics for two kinds of incorrect initializer reference

- Attempting to construct class object using metatype value via
  non-required initializer

- Referencing initializer of protocol metatype base

Both of the diagnostics are used by `AllowInvalidInitRef` fix.

Author: xedin

lib/Sema/CSDiagnostics.cpp

@@ -1506,3 +1506,27 @@ bool PartialApplicationFailure::diagnoseAsError() {
   emitDiagnostic(anchor->getNameLoc(), diagnostic, kind);
   return true;
 }
+
+bool InvalidDynamicInitOnMetatypeFailure::diagnoseAsError() {
+  auto *anchor = getRawAnchor();
+  emitDiagnostic(anchor->getLoc(), diag::dynamic_construct_class,
+                 BaseType->getMetatypeInstanceType())
+      .highlight(BaseRange);
+  emitDiagnostic(Init, diag::note_nonrequired_initializer, Init->isImplicit(),
+                 Init->getFullName());
+  return true;
+}
+
+bool InitOnProtocolMetatypeFailure::diagnoseAsError() {
+  auto *anchor = getRawAnchor();
+  if (IsStaticallyDerived) {
+    emitDiagnostic(anchor->getLoc(), diag::construct_protocol_by_name,
+                   BaseType->getMetatypeInstanceType())
+        .highlight(BaseRange);
+  } else {
+    emitDiagnostic(anchor->getLoc(), diag::construct_protocol_value, BaseType)
+        .highlight(BaseRange);
+  }
+
+  return true;
+}

lib/Sema/CSDiagnostics.h

@@ -707,6 +707,70 @@ class PartialApplicationFailure final : public FailureDiagnostic {
   bool diagnoseAsError() override;
 };
 
+class InvalidInitRefFailure : public FailureDiagnostic {
+protected:
+  Type BaseType;
+  const ConstructorDecl *Init;
+  SourceRange BaseRange;
+
+  InvalidInitRefFailure(Expr *root, ConstraintSystem &cs, Type baseTy,
+                        const ConstructorDecl *init, SourceRange baseRange,
+                        ConstraintLocator *locator)
+      : FailureDiagnostic(root, cs, locator), BaseType(baseTy), Init(init),
+        BaseRange(baseRange) {}
+
+public:
+  bool diagnoseAsError() override = 0;
+};
+
+/// Diagnose an attempt to construct an object of class type with a metatype
+/// value without using 'required' initializer:
+///
+/// ```swift
+///  class C {
+///    init(value: Int) {}
+///  }
+///
+///  func make<T: C>(type: T.Type) -> T {
+///    return T.init(value: 42)
+///  }
+/// ```
+class InvalidDynamicInitOnMetatypeFailure final : public InvalidInitRefFailure {
+public:
+  InvalidDynamicInitOnMetatypeFailure(Expr *root, ConstraintSystem &cs,
+                                      Type baseTy, const ConstructorDecl *init,
+                                      SourceRange baseRange,
+                                      ConstraintLocator *locator)
+      : InvalidInitRefFailure(root, cs, baseTy, init, baseRange, locator) {}
+
+  bool diagnoseAsError() override;
+};
+
+/// Diagnose an attempt to call initializer on protocol metatype:
+///
+/// ```swift
+///  protocol P {
+///    init(value: Int)
+///  }
+///
+///  func make(type: P.Type) -> P {
+///    return type.init(value: 42)
+///  }
+/// ```
+class InitOnProtocolMetatypeFailure final : public InvalidInitRefFailure {
+  bool IsStaticallyDerived;
+
+public:
+  InitOnProtocolMetatypeFailure(Expr *root, ConstraintSystem &cs, Type baseTy,
+                                const ConstructorDecl *init,
+                                bool isStaticallyDerived, SourceRange baseRange,
+                                ConstraintLocator *locator)
+      : InvalidInitRefFailure(root, cs, baseTy, init, baseRange, locator),
+        IsStaticallyDerived(isStaticallyDerived) {}
+
+  bool diagnoseAsError() override;
+};
+
 } // end namespace constraints
 } // end namespace swift
 

lib/Sema/CSFix.cpp

@@ -277,7 +277,20 @@ AllowInvalidPartialApplication::create(bool isWarning, ConstraintSystem &cs,
 }
 
 bool AllowInvalidInitRef::diagnose(Expr *root, bool asNote) const {
-  return false;
+  switch (Kind) {
+  case RefKind::DynamicOnMetatype: {
+    InvalidDynamicInitOnMetatypeFailure failure(
+        root, getConstraintSystem(), BaseType, Init, BaseRange, getLocator());
+    return failure.diagnose(asNote);
+  }
+
+  case RefKind::ProtocolMetatype: {
+    InitOnProtocolMetatypeFailure failure(root, getConstraintSystem(), BaseType,
+                                          Init, IsStaticallyDerived, BaseRange,
+                                          getLocator());
+    return failure.diagnose(asNote);
+  }
+  }
 }
 
 AllowInvalidInitRef *AllowInvalidInitRef::dynamicOnMetatype(

test/expr/postfix/dot/init_ref_delegation.swift

@@ -113,7 +113,7 @@ class Z4 {
 
   convenience init(other: Z4) {
     other.init() // expected-error{{'init' is a member of the type; use 'type(of: ...)' to initialize a new object of the same dynamic type}} {{11-11=type(of: }} {{15-15=)}} 
-    type(of: other).init() // expected-error{{must use a 'required' initializer}} expected-warning{{unused}}
+    type(of: other).init() // expected-error{{must use a 'required' initializer}}
   }
 }