[Sema] Diagnose availability via TypeReprs rather than Types.

The code that diagnosed availability for types was reverse-engineering
the Type itself, rather than making use of the declaration already
stored within the TypeRepr. 

More importantly, it would completely skip nested types, so it would
fail to diagnose a deprecated/unavailable “Bar” in “Foo.Bar”. 

Replace the type-inspecting check with a much-simpler walk over the 
components of the IdentTypeRepr that looks at the declarations stored 
in the IdentTypeRepr directly. This provides proper source-location
information and handles nested types.

This is a source-breaking change for ill-formed Swift 3 code that used
nested type references to refer to something that should be unavailable.
Given that such Swift 3 code was ill-formed, and most uses of it would
crash at runtime, we likely do not need to provide specific logic to
address this in Swift 3 compatibility mode.

Author: DougGregor

lib/AST/Type.cpp

@@ -981,6 +981,10 @@ TypeDecl *TypeBase::getDirectlyReferencedTypeDecl() const {
     return nullptr;
   }
 
+  if (auto substituted = dyn_cast<SubstitutedType>(this)) {
+    return substituted->getOriginal()->getDirectlyReferencedTypeDecl();
+  }
+  
   return nullptr;
 }
 

lib/Sema/TypeCheckType.cpp

@@ -1340,55 +1340,18 @@ static Type resolveIdentTypeComponent(
                                          unsatisfiedDependency);
 }
 
-static bool checkTypeDeclAvailability(const TypeDecl *TypeDecl,
-                                      IdentTypeRepr *IdType,
-                                      SourceLoc Loc, DeclContext *DC,
-                                      TypeChecker &TC,
-                                      bool AllowPotentiallyUnavailableProtocol){
-  if (isa<ComponentIdentTypeRepr>(IdType)) {
-    return diagnoseDeclAvailability(TypeDecl, TC, DC, Loc,
-                                    AllowPotentiallyUnavailableProtocol,
-                                    false);
-  }
-
-  return false;
-}
-
-
-static bool diagnoseAvailability(Type ty, IdentTypeRepr *IdType, SourceLoc Loc,
+static bool diagnoseAvailability(IdentTypeRepr *IdType,
                                  DeclContext *DC, TypeChecker &TC,
                                  bool AllowPotentiallyUnavailableProtocol) {
-  if (auto *NAT = dyn_cast<NameAliasType>(ty.getPointer())) {
-    if (checkTypeDeclAvailability(NAT->getDecl(), IdType, Loc, DC, TC,
-                                  AllowPotentiallyUnavailableProtocol))
-      return true;
-  }
-
-  if (auto *GPT = dyn_cast<GenericTypeParamType>(ty.getPointer())) {
-    if (auto GP = GPT->getDecl()) {
-      if (checkTypeDeclAvailability(GP, IdType, Loc, DC, TC,
-                                    AllowPotentiallyUnavailableProtocol)) {
+  for (auto comp : IdType->getComponentRange()) {
+    if (auto typeDecl = dyn_cast_or_null<TypeDecl>(comp->getBoundDecl())) {
+      if (diagnoseDeclAvailability(typeDecl, TC, DC, comp->getIdLoc(),
+                                   AllowPotentiallyUnavailableProtocol,
+                                   false))
         return true;
-      }
-    }
-  }
-
-  // Look through substituted types to diagnose when the original
-  // type is marked unavailable.
-  if (auto *ST = dyn_cast<SubstitutedType>(ty.getPointer())) {
-    if (diagnoseAvailability(ST->getOriginal(), IdType, Loc, DC, TC,
-                             AllowPotentiallyUnavailableProtocol)) {
-      return true;
     }
   }
 
-  CanType canTy = ty.getCanonicalTypeOrNull();
-  if (canTy.isNull())
-    return false;
-  if (auto NTD = canTy.getAnyNominal())
-    return checkTypeDeclAvailability(NTD, IdType, Loc, DC, TC,
-                                     AllowPotentiallyUnavailableProtocol);
-
   return false;
 }
 
@@ -1468,8 +1431,7 @@ Type TypeChecker::resolveIdentifierType(
 
   // Check the availability of the type.
   if (!(options & TR_AllowUnavailable) &&
-      diagnoseAvailability(result, IdType,
-                           Components.back()->getIdLoc(), DC, *this,
+      diagnoseAvailability(IdType, DC, *this,
                            AllowPotentiallyUnavailableProtocol)) {
     Components.back()->setInvalid();
     return ErrorType::get(Context);

test/Interpreter/SDK/submodules_smoke_test.swift

@@ -15,6 +15,8 @@ import AppKit.NSPanGestureRecognizer
 
 @available(OSX, introduced: 10.10)
 typealias PanRecognizer = NSPanGestureRecognizer
+
+@available(OSX, introduced: 10.10)
 typealias PanRecognizer2 = AppKit.NSPanGestureRecognizer
 
 #if !NO_ERROR

test/Sema/availability.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -module-name MyModule
 
 // REQUIRES: OS=macosx
 
@@ -10,10 +10,21 @@ func test() {
 }
 
 @available(*,unavailable,message: "use 'Int' instead")
-struct NSUInteger {} // expected-note 2 {{explicitly marked unavailable here}}
+struct NSUInteger {} // expected-note 3 {{explicitly marked unavailable here}}
+
+struct Outer {
+  @available(*,unavailable,message: "use 'UInt' instead")
+  struct NSUInteger {} // expected-note 2 {{explicitly marked unavailable here}}
+}
 
 func foo(x : NSUInteger) { // expected-error {{'NSUInteger' is unavailable: use 'Int' instead}}
      let y : NSUInteger = 42 // expected-error {{'NSUInteger' is unavailable: use 'Int' instead}}
+
+  let z : MyModule.NSUInteger = 42 // expected-error {{'NSUInteger' is unavailable: use 'Int' instead}}
+
+  let z2 : Outer.NSUInteger = 42 // expected-error {{'NSUInteger' is unavailable: use 'UInt' instead}}  
+
+  let z3 : MyModule.Outer.NSUInteger = 42 // expected-error {{'NSUInteger' is unavailable: use 'UInt' instead}}  
 }
 
 // Test preventing overrides of unavailable methods.