[sema] Add compiler fixit for the case where a raw-representable type is constructed from an argument with the same type.

Like this:

  MyEnumType(MyEnumType.foo)

This is missing 'rawValue:' label, but that won't actually fix this. A better fix is to just remove the unnecessary constructor call:

  MyEnumType(MyEnumType.foo)
-->
  MyEnumType.foo

Author: akyrtzi

include/swift/AST/DiagnosticsSema.def

@@ -758,6 +758,9 @@ ERROR(instance_member_in_initializer,none,
       "cannot use instance member %0 within property initializer; "
       "property initializers run before 'self' is available", (DeclName))
 
+ERROR(invalid_initialization_parameter_same_type,none,
+      "invalid initializer call with same type %0 as parameter", (Type))
+
 ERROR(missing_argument_named,none,
       "missing argument for parameter %0 in call", (Identifier))
 ERROR(missing_argument_positional,none,

lib/Sema/CSDiag.cpp

@@ -3099,10 +3099,8 @@ static bool isIntegerType(Type fromType, ConstraintSystem *CS) {
                                   CS);
 }
 
-/// Return true if the given type conforms to RawRepresentable, with an
-/// underlying type conforming to the given known protocol.
+/// Return true if the given type conforms to RawRepresentable.
 static Type isRawRepresentable(Type fromType,
-                               KnownProtocolKind kind,
                                ConstraintSystem *CS) {
   auto rawReprType =
     CS->TC.getProtocol(SourceLoc(), KnownProtocolKind::RawRepresentable);
@@ -3119,6 +3117,15 @@ static Type isRawRepresentable(Type fromType,
                                                          conformance,
                                   CS->getASTContext().getIdentifier("RawValue"),
                                                          &CS->TC);
+  return rawTy;
+}
+
+/// Return true if the given type conforms to RawRepresentable, with an
+/// underlying type conforming to the given known protocol.
+static Type isRawRepresentable(Type fromType,
+                               KnownProtocolKind kind,
+                               ConstraintSystem *CS) {
+  Type rawTy = isRawRepresentable(fromType, CS);
   if (!rawTy || !isLiteralConvertibleType(rawTy, kind, CS))
     return Type();
 
@@ -3800,6 +3807,45 @@ static bool diagnoseSingleCandidateFailures(CalleeCandidateInfo &CCI,
       }
   }
 
+  // Check the case where a raw-representable type is constructed from an
+  // argument with the same type:
+  //
+  //    MyEnumType(MyEnumType.foo)
+  //
+  // This is missing 'rawValue:' label, but a better fix is to just remove the
+  // unnecessary constructor call:
+  //
+  //    MyEnumType.foo
+  //
+  if (params.size() == 1 && args.size() == 1 &&
+      candidate.getDecl() && isa<ConstructorDecl>(candidate.getDecl()) &&
+      candidate.level == 1) {
+    CallArgParam &arg = args[0];
+    auto resTy = candidate.getResultType();
+    if (auto unwrappedOpt = resTy->getOptionalObjectType())
+      resTy = unwrappedOpt;
+    auto rawTy = isRawRepresentable(resTy, CCI.CS);
+    if (rawTy && resTy->getCanonicalType() == arg.Ty.getCanonicalTypeOrNull()) {
+      auto getInnerExpr = [](Expr *E) -> Expr* {
+        ParenExpr *parenE = dyn_cast<ParenExpr>(E);
+        if (!parenE)
+          return nullptr;
+        return parenE->getSubExpr();
+      };
+      Expr *innerE = getInnerExpr(argExpr);
+
+      InFlightDiagnostic diag = TC.diagnose(fnExpr->getLoc(),
+          diag::invalid_initialization_parameter_same_type, resTy);
+      diag.highlight((innerE ? innerE : argExpr)->getSourceRange());
+      if (innerE) {
+        // Remove the unnecessary constructor call.
+        diag.fixItRemoveChars(fnExpr->getLoc(), innerE->getStartLoc())
+          .fixItRemove(argExpr->getEndLoc());
+      }
+      return true;
+    }
+  }
+
   // We only handle structural errors here.
   if (CCI.closeness != CC_ArgumentLabelMismatch &&
       CCI.closeness != CC_ArgumentCountMismatch)

test/FixCode/fixits-apply.swift

@@ -49,6 +49,11 @@ func testMask4(a: MyEventMask2) {
   testMask2(a: a)
 }
 
+enum MyEnumType : UInt32 {
+  case invalid
+}
+_ = MyEnumType(MyEnumType.invalid)
+
 func goo(var e : ErrorProtocol) {
 }
 func goo2(var e: ErrorProtocol) {}

test/FixCode/fixits-apply.swift.result

@@ -49,6 +49,11 @@ func testMask4(a: MyEventMask2) {
   testMask2(a: a.rawValue)
 }
 
+enum MyEnumType : UInt32 {
+  case invalid
+}
+_ = MyEnumType.invalid
+
 func goo(e : ErrorProtocol) {
     var e = e
 }