[Type checker] Don't overflow array bounds with #fileLiteral

lib/Sema/ConstraintSystem.cpp

@@ -249,6 +249,7 @@ getAlternativeLiteralTypes(KnownProtocolKind kind) {
   case KnownProtocolKind::ExpressibleByImageLiteral: index = 11; break;
   case KnownProtocolKind::ExpressibleByFileReferenceLiteral: index = 12; break;
   }
+  static_assert(NumAlternativeLiteralTypes == 13, "Wrong # of literal types");
 
   // If we already looked for alternative literal types, return those results.
   if (AlternativeLiteralTypes[index])

lib/Sema/ConstraintSystem.h

@@ -925,7 +925,8 @@ class ConstraintSystem {
     MemberLookups;
 
   /// Cached sets of "alternative" literal types.
-  Optional<ArrayRef<Type>> AlternativeLiteralTypes[12];
+  static const unsigned NumAlternativeLiteralTypes = 13;
+  Optional<ArrayRef<Type>> AlternativeLiteralTypes[NumAlternativeLiteralTypes];
 
   /// \brief Folding set containing all of the locators used in this
   /// constraint system.

lib/Sema/TypeCheckExprObjC.cpp

@@ -161,7 +161,8 @@ Optional<Type> TypeChecker::checkObjCKeyPathExpr(DeclContext *dc,
 
   // Local function to perform name lookup for the current index.
   auto performLookup = [&](unsigned idx, Identifier componentName,
-                           SourceLoc componentNameLoc) -> LookupResult {
+                           SourceLoc componentNameLoc,
+                           Type &lookupType) -> LookupResult {
     if (state == Beginning)
       return lookupUnqualified(dc, componentName, componentNameLoc);
 
@@ -170,7 +171,6 @@ Optional<Type> TypeChecker::checkObjCKeyPathExpr(DeclContext *dc,
     // Determine the type in which the lookup should occur. If we have
     // a bridged value type, this will be the Objective-C class to
     // which it is bridged.
-    Type lookupType;
     if (auto bridgedClass = Context.getBridgedToObjC(dc, currentType))
       lookupType = bridgedClass;
     else
@@ -210,15 +210,17 @@ Optional<Type> TypeChecker::checkObjCKeyPathExpr(DeclContext *dc,
     }
 
     // Look for this component.
-    LookupResult lookup = performLookup(idx, componentName, componentNameLoc);
+    Type lookupType;
+    LookupResult lookup = performLookup(idx, componentName, componentNameLoc,
+                                        lookupType);
 
     // If we didn't find anything, try to apply typo-correction.
     bool resultsAreFromTypoCorrection = false;
     if (!lookup) {
-      performTypoCorrection(dc, DeclRefKind::Ordinary, currentType,
+      performTypoCorrection(dc, DeclRefKind::Ordinary, lookupType,
                             componentName, componentNameLoc,
-                            (currentType ? defaultMemberTypeLookupOptions
-                                         : defaultUnqualifiedLookupOptions),
+                            (lookupType ? defaultMemberTypeLookupOptions
+                                        : defaultUnqualifiedLookupOptions),
                             lookup);
 
       if (currentType)
@@ -263,7 +265,7 @@ Optional<Type> TypeChecker::checkObjCKeyPathExpr(DeclContext *dc,
       if (resultsAreFromTypoCorrection)
         break;
 
-      if (currentType)
+      if (lookupType)
         diagnose(componentNameLoc, diag::ambiguous_member_overload_set,
                  componentName);
       else
@@ -325,9 +327,9 @@ Optional<Type> TypeChecker::checkObjCKeyPathExpr(DeclContext *dc,
       }
 
       Type newType;
-      if (currentType && !currentType->isAnyObject()) {
-        newType = currentType->getTypeOfMember(dc->getParentModule(), type,
-                                               this);
+      if (lookupType && !lookupType->isAnyObject()) {
+        newType = lookupType->getTypeOfMember(dc->getParentModule(), type,
+                                              this);
       } else {
         newType = type->getDeclaredInterfaceType();
       }

test/Sema/object_literals_osx.swift

@@ -22,3 +22,5 @@ struct Path: _ExpressibleByFileReferenceLiteral {
 
 let p1: Path = #fileLiteral(resourceName: "what.txt")
 let p2 = #fileLiteral(resourceName: "what.txt") // expected-error{{could not infer type of file reference literal}} expected-note{{import Foundation to use 'URL' as the default file reference literal type}}
+
+let text = #fileLiteral(resourceName: "TextFile.txt").relativeString! // expected-error{{type of expression is ambiguous without more context}}

test/expr/unary/keypath/keypath.swift

@@ -33,6 +33,16 @@ class C {
   var nonObjC: String? // expected-note{{add '@objc' to expose this var to Objective-C}}{{3-3=@objc }}
 }
 
+extension NSArray {
+  @objc class Foo : NSObject {
+    @objc var propString: String = ""
+  }
+}
+
+extension Array {
+  typealias Foo = NSArray.Foo
+}
+
 func testKeyPath(a: A, b: B) {
   // Property
   let _: String = #keyPath(A.propB)
@@ -84,6 +94,10 @@ func testKeyPath(a: A, b: B) {
 
   // Property with keyword name.
   let _: String = #keyPath(A.repeat)
+
+  // Nested type of a bridged type (rdar://problem/28061409).
+  typealias IntArray = [Int]
+  let _: String = #keyPath(IntArray.Foo.propString)
 }
 
 func testAsStaticString() {