Sema: Remove redundant mapType{Into,OutOf}Context() calls

The code in recordTypeWitness() seemed to be completely bogus;
it already receives a type written in terms of the archetypes
of the adoptee's context, so mapTypeOutOfContext() did nothing
here, because it was using the wrong substitutions.

The logic for synthesizing designated initializers was also
slightly wrong if the class was nested inside a generic
function.

Finally, interface and contextual types of a derived rawValue
were flipped around.

Author: slavapestov

lib/Sema/CodeSynthesis.cpp

@@ -2060,15 +2060,17 @@ swift::createDesignatedInitOverride(TypeChecker &tc,
     return nullptr;
 
   // Lookup will sometimes give us initializers that are from the ancestors of
-  // our immediate superclass.  So, from the superclass constructor, we look 
-  // one level up to the enclosing type context which will either be a class 
+  // our immediate superclass.  So, from the superclass constructor, we look
+  // one level up to the enclosing type context which will either be a class
   // or an extension.  We can use the type declared in that context to check
   // if it's our immediate superclass and give up if we didn't.
-  // 
+  //
   // FIXME: Remove this when lookup of initializers becomes restricted to our
   // immediate superclass.
-  Type superclassTyInCtor = superclassCtor->getDeclContext()->getDeclaredTypeInContext();
+  Type superclassTyInCtor = superclassCtor->getDeclContext()->getDeclaredTypeOfContext();
   Type superclassTy = classDecl->getSuperclass();
+  Type superclassTyInContext = ArchetypeBuilder::mapTypeIntoContext(
+      classDecl, superclassTy);
   NominalTypeDecl *superclassDecl = superclassTy->getAnyNominal();
   if (superclassTyInCtor->getAnyNominal() != superclassDecl) {
     return nullptr;
@@ -2093,7 +2095,7 @@ swift::createDesignatedInitOverride(TypeChecker &tc,
   if (superclassDecl->isGenericContext()) {
     if (auto *superclassSig = superclassDecl->getGenericSignatureOfContext()) {
       auto *moduleDecl = classDecl->getParentModule();
-      auto subs = superclassTy->gatherAllSubstitutions(
+      auto subs = superclassTyInContext->gatherAllSubstitutions(
           moduleDecl, nullptr, nullptr);
       auto subsMap = superclassSig->getSubstitutionMap(subs);
 
@@ -2103,13 +2105,14 @@ swift::createDesignatedInitOverride(TypeChecker &tc,
         auto paramTy = ArchetypeBuilder::mapTypeOutOfContext(
             superclassDecl, decl->getType());
 
-        // Apply the superclass substitutions to produce an interface
-        // type in terms of the class generic signature.
+        // Apply the superclass substitutions to produce a contextual
+        // type in terms of the derived class archetypes.
         auto paramSubstTy = paramTy.subst(moduleDecl, subsMap, SubstOptions());
-        decl->setInterfaceType(paramSubstTy);
+        decl->overwriteType(paramSubstTy);
 
-        // Map it to a contextual type in terms of the class's archetypes.
-        decl->overwriteType(ArchetypeBuilder::mapTypeIntoContext(
+        // Map it to an interface type in terms of the derived class
+        // generic signature.
+        decl->setInterfaceType(ArchetypeBuilder::mapTypeOutOfContext(
             classDecl, paramSubstTy));
       }
     }

lib/Sema/DerivedConformanceRawRepresentable.cpp

@@ -141,8 +141,9 @@ static VarDecl *deriveRawRepresentable_raw(TypeChecker &tc,
   PatternBindingDecl *pbDecl;
   std::tie(propDecl, pbDecl)
     = declareDerivedReadOnlyProperty(tc, parentDecl, enumDecl,
-                                     C.Id_rawValue, rawType,
+                                     C.Id_rawValue,
                                      rawInterfaceType,
+                                     rawType,
                                      getterDecl);
 
   auto dc = cast<IterableDeclContext>(parentDecl);

lib/Sema/TypeCheckDecl.cpp

@@ -372,9 +372,8 @@ void TypeChecker::checkInheritanceClause(Decl *decl,
       continue;
 
     // Retrieve the interface type for this inherited type.
-    if (DC->isGenericContext() && DC->isTypeContext()) {
+    if (inheritedTy->hasArchetype())
       inheritedTy = ArchetypeBuilder::mapTypeOutOfContext(DC, inheritedTy);
-    }
 
     // Check whether we inherited from the same type twice.
     CanType inheritedCanTy = inheritedTy->getCanonicalType();

lib/Sema/TypeCheckGeneric.cpp

@@ -626,14 +626,7 @@ void TypeChecker::configureInterfaceType(AbstractFunctionDecl *func) {
         initArgTy = func->computeInterfaceSelfType(/*isInitializingCtor=*/true);
       }
     } else {
-      argTy = paramLists[e - i - 1]->getType(Context);
-
-      // For an implicit declaration, our argument type will be in terms of
-      // archetypes rather than dependent types. Replace the
-      // archetypes with their corresponding dependent types.
-      if (func->isImplicit()) {
-        argTy = ArchetypeBuilder::mapTypeOutOfContext(func, argTy); 
-      }
+      argTy = paramLists[e - i - 1]->getInterfaceType(func);
 
       if (initFuncTy)
         initArgTy = argTy;
@@ -653,9 +646,12 @@ void TypeChecker::configureInterfaceType(AbstractFunctionDecl *func) {
   }
 
   // Record the interface type.
+  assert(!funcTy->hasArchetype());
   func->setInterfaceType(funcTy);
-  if (initFuncTy)
+  if (initFuncTy) {
+    assert(!initFuncTy->hasArchetype());
     cast<ConstructorDecl>(func)->setInitializerInterfaceType(initFuncTy);
+  }
 
   if (func->getGenericParams()) {
     // Collect all generic params referenced in parameter types,

lib/Sema/TypeCheckProtocol.cpp

@@ -1889,17 +1889,6 @@ void ConformanceChecker::recordTypeWitness(AssociatedTypeDecl *assocType,
                                            TypeDecl *typeDecl,
                                            DeclContext *fromDC,
                                            bool performRedeclarationCheck) {
-  // If the declaration context from which the type witness was determined
-  // differs from that of the conformance, adjust the type so that it is
-  // based on the declaration context of the conformance.
-  if (fromDC != DC && DC->getGenericSignatureOfContext() &&
-      fromDC->getGenericSignatureOfContext() && !isa<ProtocolDecl>(fromDC)) {
-    // Map the type to an interface type.
-    type = ArchetypeBuilder::mapTypeOutOfContext(fromDC, type);
-
-    // Map the type into the conformance's context.
-    type = Adoptee->getTypeOfMember(DC->getParentModule(), type, fromDC);
-  }
 
   // If we already recoded this type witness, there's nothing to do.
   if (Conformance->hasTypeWitness(assocType)) {

test/decl/inherit/initializer.swift

@@ -142,3 +142,11 @@ class SuperVariadic {
 
 class SubVariadic : SuperVariadic { } // expected-warning 4{{synthesizing a variadic inherited initializer for subclass 'SubVariadic' is unsupported}}
 
+// Don't crash with invalid nesting of class in generic function
+
+func testClassInGenericFunc<T>(t: T) {
+  class A { init(t: T) {} } // expected-error {{type 'A' cannot be nested in generic function 'testClassInGenericFunc'}}
+  class B : A {} // expected-error {{type 'B' cannot be nested in generic function 'testClassInGenericFunc'}}
+
+  _ = B(t: t)
+}