Sema: References to TypeDecls should always be TypeExpr

In a few corner cases we built DeclRefExpr and MemberRefExpr
for references to types. These should just be TypeExpr so that
SILGen doesn't have to deal with it.

This also fixes a bug where a protocol typealias with an
unbound generic type could not be accessed properly from
expression context, but that is just so incredibly obscure.

Author: slavapestov

lib/SILGen/SILGenExpr.cpp

@@ -866,15 +866,6 @@ emitRValueForDecl(SILLocation loc, ConcreteDeclRef declRef, Type ncRefType,
     return emitUndefRValue(loc, refType);
   }
 
-  // If this is a reference to a type, produce a metatype.
-  if (isa<TypeDecl>(decl)) {
-    assert(refType->is<MetatypeType>() &&
-           "type declref does not have metatype type?!");
-    return RValue(*this, loc, refType,
-                  ManagedValue::forUnmanaged(
-                    B.createMetatype(loc, getLoweredType(refType))));
-  }
-  
   // If this is a reference to a var, emit it as an l-value and then load.
   if (auto *var = dyn_cast<VarDecl>(decl)) {
     assert(!declRef.isSpecialized() &&
@@ -883,6 +874,8 @@ emitRValueForDecl(SILLocation loc, ConcreteDeclRef declRef, Type ncRefType,
     return emitRValueForNonMemberVarDecl(loc, var, refType, semantics, C);
   }
 
+  assert(!isa<TypeDecl>(decl));
+
   // If the referenced decl isn't a VarDecl, it should be a constant of some
   // sort.
   SILDeclRef silDeclRef(decl);
@@ -2016,14 +2009,7 @@ RValue RValueEmitter::visitMemberRefExpr(MemberRefExpr *e,
                                          SGFContext resultCtx) {
   assert(!e->getType()->is<LValueType>() &&
          "RValueEmitter shouldn't be called on lvalues");
-
-  if (isa<TypeDecl>(e->getMember().getDecl())) {
-    // Emit the metatype for the associated type.
-    visit(e->getBase());
-    SILValue mt =
-        SGF.B.createMetatype(e, SGF.getLoweredLoadableType(e->getType()));
-    return RValue(SGF, e, ManagedValue::forUnmanaged(mt));
-  }
+  assert(isa<VarDecl>(e->getMember().getDecl()));
 
   // Everything else should use the l-value logic.
 

lib/Sema/CSApply.cpp

@@ -551,6 +551,16 @@ namespace {
                               /*isDynamic=*/false);
       }
 
+      auto type = solution.simplifyType(openedType);
+
+      if (isa<TypeDecl>(decl) && !isa<ModuleDecl>(decl)) {
+        auto typeExpr = TypeExpr::createImplicitHack(
+          loc.getBaseNameLoc(), type->getMetatypeInstanceType(),
+          ctx);
+        cs.cacheType(typeExpr);
+        return typeExpr;
+      }
+
       SubstitutionMap substitutions;
 
       // Due to a SILGen quirk, unqualified property references do not
@@ -562,7 +572,6 @@ namespace {
             locator);
       }
 
-      auto type = solution.simplifyType(openedType);
       auto declRefExpr =
         new (ctx) DeclRefExpr(ConcreteDeclRef(decl, substitutions),
                               loc, implicit, semantics, type);
@@ -842,6 +851,20 @@ namespace {
         return forceUnwrapIfExpected(DSBI, choice, memberLocator);
       }
 
+      // If we're referring to a member type, it's just a type
+      // reference.
+      if (isa<TypeDecl>(member)) {
+        Type refType = simplifyType(openedType);
+        auto ref =
+            TypeExpr::createImplicitHack(memberLoc.getBaseNameLoc(),
+                                         refType, context);
+        cs.setType(ref, refType);
+        auto *result = new (context) DotSyntaxBaseIgnoredExpr(
+            base, dotLoc, ref, refType);
+        cs.setType(result, refType);
+        return result;
+      }
+
       // The formal type of the 'self' value for the member's declaration.
       Type containerTy = getBaseType(refTy->castTo<FunctionType>());
 
@@ -983,8 +1006,8 @@ namespace {
             member->getAttrs().hasAttribute<OptionalAttr>());
       }
 
-      // For types and properties, build member references.
-      if (isa<TypeDecl>(member) || isa<VarDecl>(member)) {
+      // For properties, build member references.
+      if (isa<VarDecl>(member)) {
         assert(!dynamicSelfFnType && "Converted type doesn't make sense here");
         if (!baseIsInstance && member->isInstanceMember()) {
           assert(memberLocator.getBaseLocator() && 

lib/Sema/ConstraintSystem.cpp

@@ -1206,19 +1206,6 @@ ConstraintSystem::getTypeOfMemberReference(
 
   FunctionType::Param baseObjParam(baseObjTy);
 
-  // Don't open existentials when accessing typealias members of
-  // protocols.
-  if (auto *alias = dyn_cast<TypeAliasDecl>(value)) {
-    if (baseObjTy->isExistentialType()) {
-      auto memberTy = alias->getInterfaceType();
-      // If we end up with a protocol typealias here, it's underlying
-      // type must be fully concrete.
-      assert(!memberTy->hasTypeParameter());
-      auto openedType = FunctionType::get({baseObjParam}, memberTy);
-      return { openedType, memberTy };
-    }
-  }
-
   if (auto *typeDecl = dyn_cast<TypeDecl>(value)) {
     assert(!isa<ModuleDecl>(typeDecl) && "Nested module?");
 

test/Constraints/protocols.swift

@@ -110,6 +110,7 @@ protocol P : Initable {
 
   typealias E = Int
   typealias F = Self.E
+  typealias G = Array
 }
 
 protocol ClassP : class {
@@ -226,6 +227,9 @@ func staticExistential(_ p: P.Type, pp: P.Protocol) {
 
   _ = pp.F.self
   _ = p.F.self
+
+  // Make sure that we open generics
+  let _: [Int].Type = p.G.self
 }
 
 protocol StaticP {

test/Sema/typo_correction.swift

@@ -121,7 +121,7 @@ protocol P {} // expected-error {{invalid redeclaration of 'P'}}
 // expected-note@-1 {{did you mean 'P'?}}
 
 func hasTypo() {
-  _ = P.a.a // expected-error {{type 'P.a' (aka 'Generic') has no member 'a'}}
+  _ = P.a.a // expected-error {{type 'Generic<_>' has no member 'a'}}
 }
 
 // Typo correction with AnyObject.