---

yaml
---
r: 347455
b: refs/heads/master
c: 2ae0ebc
h: refs/heads/master
i:
  347453: f4ea297
  347451: 384251f
  347447: ef08211
  347439: df24e56
  347423: 678c49d
  347391: 15a21f2

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 67c4211041515506fa70eaf5acfae9ecaae72c25
+refs/heads/master: 2ae0ebc49cff1da15b1e6e3c0653e5d3f7a0d176
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/lib/AST/ASTVerifier.cpp

@@ -1819,7 +1819,7 @@ class Verifier : public ASTWalker {
 
       // The base of a member reference cannot be an existential type.
       if (E->getBase()->getType()->getWithoutSpecifierType()
-            ->isAnyExistentialType()) {
+            ->isExistentialType()) {
         Out << "Member reference into an unopened existential type\n";
         E->dump(Out);
         Out << "\n";

trunk/lib/Sema/CSApply.cpp

@@ -811,8 +811,10 @@ namespace {
       // Figure out the actual base type, and whether we have an instance of
       // that type or its metatype.
       bool baseIsInstance = true;
+      bool isExistentialMetatype = false;
       if (auto baseMeta = baseTy->getAs<AnyMetatypeType>()) {
         baseIsInstance = false;
+        isExistentialMetatype = baseMeta->is<ExistentialMetatypeType>();
         baseTy = baseMeta->getInstanceType();
       }
 
@@ -900,11 +902,15 @@ namespace {
                  base, selfParamTy, member, semantics,
                  locator.withPathElement(ConstraintLocator::MemberRefBase));
       } else {
-        // Convert the base to an rvalue of the appropriate metatype.
-        base = coerceToType(base,
-                            MetatypeType::get(isDynamic ? selfTy : containerTy),
-                            locator.withPathElement(
-                              ConstraintLocator::MemberRefBase));
+        if (!isExistentialMetatype || openedExistential) {
+          // Convert the base to an rvalue of the appropriate metatype.
+          base = coerceToType(base,
+                              MetatypeType::get(
+                                isDynamic ? selfTy : containerTy),
+                              locator.withPathElement(
+                                ConstraintLocator::MemberRefBase));
+        }
+
         if (!base)
           return nullptr;
 

trunk/test/Constraints/protocols.swift

@@ -107,6 +107,9 @@ protocol P : Initable {
   func bar(_ x: Int)
   mutating func mut(_ x: Int)
   static func tum()
+  
+  typealias E = Int
+  typealias F = Self.E
 }
 
 protocol ClassP : class {
@@ -216,6 +219,13 @@ func staticExistential(_ p: P.Type, pp: P.Protocol) {
   // Static member of metatype -- not allowed
   _ = pp.tum // expected-error{{static member 'tum' cannot be used on protocol metatype 'P.Protocol'}}
   _ = P.tum // expected-error{{static member 'tum' cannot be used on protocol metatype 'P.Protocol'}}
+
+  // Access typealias through protocol and existential metatypes
+  _ = pp.E.self
+  _ = p.E.self
+
+  _ = pp.F.self
+  _ = p.F.self
 }
 
 protocol StaticP {