Fix the major case of <rdar://problem/23641896> QoI: Strings in Swift cannot be indexed directly with integer offsets

This adds special tuned diagnostics to handle the case when someone attempts to index
a string with an integer value, which is pretty common to do for people new to Swift.o
That said, this only handles one special case, if there are other cases that are
common, I'd love to hear about them.  Subscripts are already handled with a different
approach, I'm not sure which is better, but I added a testcase for both of them.

Author: lattner

include/swift/AST/DiagnosticsSema.def

@@ -661,6 +661,12 @@ ERROR(unbound_generic_parameter,sema_tcc,none,
 ERROR(cannot_bind_generic_parameter_to_type,sema_tcc,none,
       "cannot bind generic parameter to type %0",
       (Type))
+ERROR(string_index_not_integer,sema_tcc,none,
+      "String may not be indexed with %0, it has variable size elements",
+      (Type))
+NOTE(string_index_not_integer_note,sema_tcc,none,
+     "consider using an existing high level algorithm, "
+     "str.startIndex.advancedBy(n), or a projection like str.utf8", ())
 
 ERROR(invalid_c_function_pointer_conversion_expr,sema_tcc,none,
       "a C function pointer can only be formed from a reference to a 'func' or "

lib/Sema/CSDiag.cpp

@@ -3038,6 +3038,28 @@ bool FailureDiagnosis::diagnoseCalleeResultContextualConversionError() {
   }
 }
 
+
+/// Return true if the conversion from fromType to toType is an invalid string
+/// index operation.
+static bool isIntegerToStringIndexConversion(Type fromType, Type toType,
+                                             ConstraintSystem *CS) {
+  auto integerType =
+    CS->TC.getProtocol(SourceLoc(),
+                       KnownProtocolKind::IntegerLiteralConvertible);
+  if (!integerType) return false;
+
+  // If the from type is an integer type, and the to type is
+  // String.CharacterView.Index, then we found one.
+  if (CS->TC.conformsToProtocol(fromType, integerType, CS->DC,
+                                ConformanceCheckFlags::InExpression)) {
+    if (toType->getCanonicalType().getString() == "String.CharacterView.Index")
+      return true;
+  }
+
+  return false;
+}
+
+
 bool FailureDiagnosis::diagnoseContextualConversionError() {
   // If the constraint system has a contextual type, then we can test to see if
   // this is the problem that prevents us from solving the system.
@@ -3193,6 +3215,18 @@ bool FailureDiagnosis::diagnoseContextualConversionError() {
     return true;
   }
 
+  exprType = exprType->getRValueType();
+
+  // Special case a some common common conversions involving Swift.String
+  // indexes, catching cases where people attempt to index them with an integer.
+  if (isIntegerToStringIndexConversion(exprType, contextualType, CS)) {
+    diagnose(expr->getLoc(), diag::string_index_not_integer,
+             exprType->getRValueType())
+      .highlight(expr->getSourceRange());
+    diagnose(expr->getLoc(), diag::string_index_not_integer_note);
+    return true;
+  }
+
   // When complaining about conversion to a protocol type, complain about
   // conformance instead of "conversion".
   if (contextualType->is<ProtocolType>() ||
@@ -3221,7 +3255,7 @@ bool FailureDiagnosis::diagnoseContextualConversionError() {
         diagID = diag::noescape_functiontype_mismatch;
     }
 
-  diagnose(expr->getLoc(), diagID, exprType->getRValueType(), contextualType)
+  diagnose(expr->getLoc(), diagID, exprType, contextualType)
     .highlight(expr->getSourceRange());
   return true;
 }

test/Constraints/diagnostics.swift

@@ -675,4 +675,13 @@ func r23272739(contentType: String) {
   return actualAcceptableContentTypes.contains(contentType)  // expected-error {{unexpected non-void return value in void function}}
 }
 
+// <rdar://problem/23641896> QoI: Strings in Swift cannot be indexed directly with integer offsets
+func r23641896() {
+  var g = "Hello World"
+  g.replaceRange(0...2, with: "ce")  // expected-error {{String may not be indexed with 'Int', it has variable size elements}}
+  // expected-note @-1 {{consider using an existing high level algorithm, str.startIndex.advancedBy(n), or a projection like str.utf8}}
+
+  _ = g[12]  // expected-error {{'subscript' is unavailable: cannot subscript String with an Int, see the documentation comment for discussion}}
+
+}