Address most of Slava's commentary on this PR.

Author: DougGregor

lib/AST/DeclContext.cpp

@@ -354,8 +354,7 @@ AbstractFunctionDecl *DeclContext::getInnermostMethodContext() {
 }
 
 bool DeclContext::isTypeContext() const {
-  return (getContextKind() == DeclContextKind::GenericTypeDecl &&
-          !isa<TypeAliasDecl>(this)) ||
+  return isa<NominalTypeDecl>(this) ||
          getContextKind() == DeclContextKind::ExtensionDecl;
 }
 

lib/Sema/ITCDecl.cpp

@@ -103,7 +103,7 @@ void IterativeTypeChecker::processResolveInheritedClauseEntry(
 
   // Validate the type of this inherited clause entry.
   // FIXME: Recursion into existing type checker.
-  GenericTypeToArchetypeResolver resolver(dc->getGenericEnvironmentOfContext());
+  GenericTypeToArchetypeResolver resolver(dc);
   if (TC.validateType(*inherited, dc, options, &resolver)) {
     inherited->setInvalidType(getASTContext());
   }

lib/Sema/TypeCheckConstraints.cpp

@@ -937,8 +937,7 @@ bool PreCheckExpression::walkToClosureExprPre(ClosureExpr *closure) {
   options |= TR_InExpression;
   bool hadParameterError = false;
 
-  GenericTypeToArchetypeResolver resolver(
-      closure->getGenericEnvironmentOfContext());
+  GenericTypeToArchetypeResolver resolver(closure);
 
   if (TC.typeCheckParameterList(PL, DC, options, resolver)) {
     closure->setType(ErrorType::get(TC.Context));

lib/Sema/TypeCheckDecl.cpp

@@ -6846,25 +6846,6 @@ void TypeChecker::checkDeclCircularity(NominalTypeDecl *decl) {
   }
 }
 
-/// Determine whether the given variable is the implicit 'self' parameter for
-/// a function, and return that function if so.
-static AbstractFunctionDecl *isImplicitSelfParam(VarDecl *var){
-  if (!var->isImplicit()) return nullptr;
-
-  auto param = dyn_cast<ParamDecl>(var);
-  if (!param) return nullptr;
-
-  auto func = dyn_cast<AbstractFunctionDecl>(var->getDeclContext());
-  if (!func) return nullptr;
-
-  if (!func->getDeclContext()->isTypeContext()) return nullptr;
-
-  if (param == func->getImplicitSelfDecl())
-    return func;
-
-  return nullptr;
-}
-
 void TypeChecker::validateDecl(ValueDecl *D, bool resolveTypeParams) {
   if (hasEnabledForbiddenTypecheckPrefix())
     checkForForbiddenPrefix(D);
@@ -7112,12 +7093,12 @@ void TypeChecker::validateDecl(ValueDecl *D, bool resolveTypeParams) {
   case DeclKind::Param: {
     auto VD = cast<VarDecl>(D);
     if (!VD->hasType()) {
-      if (auto func = isImplicitSelfParam(VD)) {
+      if (VD->isSelfParameter()) {
         if (!VD->hasInterfaceType()) {
           VD->setInterfaceType(ErrorType::get(Context));
           VD->setInvalid();
         }
-        recordSelfContextType(func);
+        recordSelfContextType(cast<AbstractFunctionDecl>(VD->getDeclContext()));
       } else if (PatternBindingDecl *PBD = VD->getParentPatternBinding()) {
         if (PBD->isBeingTypeChecked()) {
           diagnose(VD, diag::pattern_used_in_type, VD->getName());

lib/Sema/TypeCheckType.cpp

@@ -201,8 +201,7 @@ Type TypeChecker::resolveTypeInContext(
        bool isSpecialized,
        GenericTypeResolver *resolver,
        UnsatisfiedDependency *unsatisfiedDependency) {
-  GenericTypeToArchetypeResolver defaultResolver(
-                                      fromDC->getGenericEnvironmentOfContext());
+  GenericTypeToArchetypeResolver defaultResolver(fromDC);
   if (!resolver)
     resolver = &defaultResolver;
 
@@ -529,8 +528,7 @@ Type TypeChecker::applyUnboundGenericArguments(
          "invalid arguments, use applyGenericArguments for diagnostic emitting");
 
   // Make sure we always have a resolver to use.
-  GenericTypeToArchetypeResolver defaultResolver(
-                                          dc->getGenericEnvironmentOfContext());
+  GenericTypeToArchetypeResolver defaultResolver(dc);
   if (!resolver)
     resolver = &defaultResolver;
 
@@ -1613,8 +1611,7 @@ Type TypeChecker::resolveType(TypeRepr *TyR, DeclContext *DC,
   PrettyStackTraceTypeRepr stackTrace(Context, "resolving", TyR);
 
   // Make sure we always have a resolver to use.
-  GenericTypeToArchetypeResolver defaultResolver(
-                                          DC->getGenericEnvironmentOfContext());
+  GenericTypeToArchetypeResolver defaultResolver(DC);
   if (!resolver)
     resolver = &defaultResolver;