Sema: Introduce metatype-to-object conversions.

Allow class metatypes (including class-constrained existential metatypes) to be treated as subtypes of AnyObject, and single-@objc protocol metatypes to be treated as subtypes of the Protocol class from objc. No codegen support yet, so this is hidden behind a frontend flag for now.

Swift SVN r18810

Author: jckarter

include/swift/AST/Expr.h

@@ -1845,6 +1845,40 @@ class ImplicitConversionExpr : public Expr {
   }
 };
 
+/// The implicit conversion from a class metatype to AnyObject.
+class ClassMetatypeToObjectExpr : public ImplicitConversionExpr {
+public:
+  ClassMetatypeToObjectExpr(Expr *subExpr, Type ty)
+    : ImplicitConversionExpr(ExprKind::ClassMetatypeToObject, subExpr, ty) {}
+  
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::ClassMetatypeToObject;
+  }
+};
+
+/// The implicit conversion from a class existential metatype to AnyObject.
+class ExistentialMetatypeToObjectExpr : public ImplicitConversionExpr {
+public:
+  ExistentialMetatypeToObjectExpr(Expr *subExpr, Type ty)
+    : ImplicitConversionExpr(ExprKind::ClassMetatypeToObject, subExpr, ty) {}
+  
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::ExistentialMetatypeToObject;
+  }
+};
+  
+/// The implicit conversion from a protocol value metatype to ObjC's Protocol
+/// class type.
+class ProtocolMetatypeToObjectExpr : public ImplicitConversionExpr {
+public:
+  ProtocolMetatypeToObjectExpr(Expr *subExpr, Type ty)
+    : ImplicitConversionExpr(ExprKind::ProtocolMetatypeToObject, subExpr, ty) {}
+  
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::ProtocolMetatypeToObject;
+  }
+};
+  
 /// InjectIntoOptionalExpr - The implicit conversion from T to T?.
 class InjectIntoOptionalExpr : public ImplicitConversionExpr {
 public:

include/swift/AST/ExprNodes.def

@@ -129,6 +129,9 @@ ABSTRACT_EXPR(ImplicitConversion, Expr)
   EXPR(ArchetypeToSuper, ImplicitConversionExpr)
   EXPR(ScalarToTuple, ImplicitConversionExpr)
   EXPR(InjectIntoOptional, ImplicitConversionExpr)
+  EXPR(ClassMetatypeToObject, ImplicitConversionExpr)
+  EXPR(ExistentialMetatypeToObject, ImplicitConversionExpr)
+  EXPR(ProtocolMetatypeToObject, ImplicitConversionExpr)
   EXPR(LValueConversion, ImplicitConversionExpr)
   EXPR(LValueToPointer, ImplicitConversionExpr)
   EXPR_RANGE(ImplicitConversion, Load, LValueToPointer)

include/swift/AST/KnownIdentifiers.def

@@ -34,6 +34,7 @@ IDENTIFIER(hashValue)
 IDENTIFIER(init)
 IDENTIFIER(objectAtIndexedSubscript)
 IDENTIFIER(objectForKeyedSubscript)
+IDENTIFIER(ObjectiveC)
 IDENTIFIER(Protocol)
 IDENTIFIER(raw)
 IDENTIFIER(RawType)

include/swift/Basic/LangOptions.h

@@ -50,6 +50,9 @@ namespace swift {
     /// \brief Enable experimental "switch" pattern-matching features.
     bool EnableExperimentalPatterns = false;
 
+    /// \brief Enable ObjC compatibility metatype-to-class conversions.
+    bool EnableMetatypeToObjectConversions = false;
+    
     /// \brief Enable features useful for running in the debugger.
     bool DebuggerSupport = false;
 

include/swift/Driver/FrontendOptions.td

@@ -123,6 +123,9 @@ def enable_dynamic_value_type_layout :
 def enable_experimental_patterns : Flag<["-"], "enable-experimental-patterns">,
   HelpText<"Enable experimental 'switch' pattern matching features">;
 
+def enable_metatype_object_conversions : Flag<["-"], "enable-metatype-object-conversions">,
+  HelpText<"Enable metatype-to-object conversions">;
+
 def enable_character_literals : Flag<["-"], "enable-character-literals">,
 HelpText<"Enable legacy character literals">;
 

lib/AST/ASTDumper.cpp

@@ -1076,7 +1076,7 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
   void visitErrorExpr(ErrorExpr *E) {
     printCommon(E, "error_expr") << ')';
   }
-
+  
   void visitIntegerLiteralExpr(IntegerLiteralExpr *E) {
     printCommon(E, "integer_literal_expr");
     if (E->isNegative())
@@ -1439,6 +1439,21 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     printRec(E->getSubExpr());
     OS << ')';
   }
+  void visitClassMetatypeToObjectExpr(ClassMetatypeToObjectExpr *E) {
+    printCommon(E, "class_metatype_to_object") << '\n';
+    printRec(E->getSubExpr());
+    OS << ')';
+  }
+  void visitExistentialMetatypeToObjectExpr(ExistentialMetatypeToObjectExpr *E) {
+    printCommon(E, "existential_metatype_to_object") << '\n';
+    printRec(E->getSubExpr());
+    OS << ')';
+  }
+  void visitProtocolMetatypeToObjectExpr(ProtocolMetatypeToObjectExpr *E) {
+    printCommon(E, "protocol_metatype_to_object") << '\n';
+    printRec(E->getSubExpr());
+    OS << ')';
+  }
 
   void visitInOutExpr(InOutExpr *E) {
     printCommon(E, "inout_expr") << '\n';

lib/Frontend/CompilerInvocation.cpp

@@ -536,6 +536,9 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
 
   Opts.EnableExperimentalPatterns |= Args.hasArg(OPT_enable_experimental_patterns);
 
+  Opts.EnableMetatypeToObjectConversions
+    |= Args.hasArg(OPT_enable_metatype_object_conversions);
+
   Opts.EnableCharacterLiterals |= Args.hasArg(OPT_enable_character_literals);
 
   Opts.DebugConstraintSolver |= Args.hasArg(OPT_debug_constraints);

lib/SILGen/SILGenExpr.cpp

@@ -221,6 +221,12 @@ namespace {
     RValue visitInjectIntoOptionalExpr(InjectIntoOptionalExpr *E, SGFContext C);
     RValue visitLValueConversionExpr(LValueConversionExpr *E, SGFContext C);
     RValue visitLValueToPointerExpr(LValueToPointerExpr *E, SGFContext C);
+    RValue visitClassMetatypeToObjectExpr(ClassMetatypeToObjectExpr *E,
+                                          SGFContext C);
+    RValue visitExistentialMetatypeToObjectExpr(ExistentialMetatypeToObjectExpr *E,
+                                                SGFContext C);
+    RValue visitProtocolMetatypeToObjectExpr(ProtocolMetatypeToObjectExpr *E,
+                                             SGFContext C);
     RValue visitIfExpr(IfExpr *E, SGFContext C);
 
     RValue visitDefaultValueExpr(DefaultValueExpr *E, SGFContext C);
@@ -4202,6 +4208,23 @@ RValue RValueEmitter::visitLValueToPointerExpr(LValueToPointerExpr *E,
   return RValue(SGF, E, ManagedValue::forUnmanaged(ptr));
 }
 
+RValue RValueEmitter::visitClassMetatypeToObjectExpr(ClassMetatypeToObjectExpr *E,
+                                                     SGFContext C) {
+  llvm_unreachable("not implemented");
+}
+
+RValue RValueEmitter::visitExistentialMetatypeToObjectExpr(
+                                             ExistentialMetatypeToObjectExpr *E,
+                                             SGFContext C) {
+  llvm_unreachable("not implemented");
+}
+
+RValue RValueEmitter::visitProtocolMetatypeToObjectExpr(
+                                             ProtocolMetatypeToObjectExpr *E,
+                                             SGFContext C) {
+  llvm_unreachable("not implemented");
+}
+
 RValue RValueEmitter::visitInOutConversionExpr(InOutConversionExpr *E,
                                                SGFContext C) {
   // Disable nested writeback scopes for any calls evaluated in the

lib/Sema/CSApply.cpp

@@ -3960,6 +3960,16 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
     case ConversionRestrictionKind::Existential:
       return coerceExistential(expr, toType, locator);
 
+    case ConversionRestrictionKind::ClassMetatypeToAnyObject: {
+      return new (tc.Context) ClassMetatypeToObjectExpr(expr, toType);
+    }
+    case ConversionRestrictionKind::ExistentialMetatypeToAnyObject: {
+      return new (tc.Context) ExistentialMetatypeToObjectExpr(expr, toType);
+    }
+    case ConversionRestrictionKind::ProtocolMetatypeToProtocolClass: {
+      return new (tc.Context) ProtocolMetatypeToObjectExpr(expr, toType);
+    }
+        
     case ConversionRestrictionKind::ValueToOptional: {
       auto toGenericType = toType->castTo<BoundGenericType>();
       assert(toGenericType->getDecl()->classifyAsOptionalType());

lib/Sema/CSSimplify.cpp

@@ -1631,6 +1631,58 @@ ConstraintSystem::matchTypes(Type type1, Type type2, TypeMatchKind kind,
       conversionsOrFixes.push_back(ConversionRestrictionKind::Superclass);
     }
 
+    // Metatype to object conversion.
+    
+    if (getASTContext().LangOpts.EnableMetatypeToObjectConversions) {
+      // These conversions are between concrete types that don't need further
+      // resolution, so we can consider them immediately solved.
+      auto addSolvedRestrictedConstraint
+        = [&](ConversionRestrictionKind restriction) -> SolutionKind {
+          auto constraint = Constraint::createRestricted(*this,
+                                                   ConstraintKind::Subtype,
+                                                   restriction,
+                                                   type1, type2,
+                                                   getConstraintLocator(locator));
+          this->addConstraint(constraint);
+          return SolutionKind::Solved;
+        };
+      
+      if (auto meta1 = type1->getAs<MetatypeType>()) {
+        // Class metatypes can be converted to AnyObject.
+        if (meta1->getInstanceType()->mayHaveSuperclass()
+            && type2->isAnyObject()) {
+          return addSolvedRestrictedConstraint(
+                             ConversionRestrictionKind::ClassMetatypeToAnyObject);
+        }
+        // Single @objc protocol value metatypes can be converted to the ObjC
+        // Protocol class type.
+        auto isProtocolClassType = [&](Type t) -> bool {
+          if (auto classDecl = t->getClassOrBoundGenericClass())
+            if (classDecl->getName() == getASTContext().Id_Protocol
+                && classDecl->getModuleContext()->Name
+                    == getASTContext().Id_ObjectiveC)
+              return true;
+          return false;
+        };
+        
+        if (auto protoTy = meta1->getInstanceType()->getAs<ProtocolType>()) {
+          if (protoTy->getDecl()->isObjC()
+              && isProtocolClassType(type2)) {
+            return addSolvedRestrictedConstraint(
+                    ConversionRestrictionKind::ProtocolMetatypeToProtocolClass);
+          }
+        }
+      }
+      if (auto meta1 = type1->getAs<ExistentialMetatypeType>()) {
+        // Class-constrained existential metatypes can be converted to AnyObject.
+        if (meta1->getInstanceType()->isClassExistentialType()
+            && type2->isAnyObject()) {
+          return addSolvedRestrictedConstraint(
+                     ConversionRestrictionKind::ExistentialMetatypeToAnyObject);
+        }
+      }
+    }
+    
     // Implicit array conversions.
     if (kind >= TypeMatchKind::Conversion) {      
       if (isArrayType(desugar1) && isArrayType(desugar2)) {
@@ -3035,6 +3087,14 @@ ConstraintSystem::simplifyRestrictedConstraint(ConversionRestrictionKind restric
                       matchKind, subFlags, locator);
   }
 
+  case ConversionRestrictionKind::ClassMetatypeToAnyObject:
+  case ConversionRestrictionKind::ExistentialMetatypeToAnyObject:
+  case ConversionRestrictionKind::ProtocolMetatypeToProtocolClass: {
+    // Nothing more to solve.
+    addContextualScore();
+    return SolutionKind::Solved;
+  }
+    
   // T < U ===> Array<T> <c Array<U>
   case ConversionRestrictionKind::ArrayUpcast: {
     auto t1 = type1->getDesugaredType();

lib/Sema/Constraint.cpp

@@ -294,6 +294,12 @@ StringRef swift::constraints::getName(ConversionRestrictionKind kind) {
     return "[unchecked-optional-to-optional]";
   case ConversionRestrictionKind::OptionalToImplicitlyUnwrappedOptional:
     return "[optional-to-unchecked-optional]";
+  case ConversionRestrictionKind::ClassMetatypeToAnyObject:
+    return "[class-metatype-to-object]";
+  case ConversionRestrictionKind::ExistentialMetatypeToAnyObject:
+    return "[existential-metatype-to-object]";
+  case ConversionRestrictionKind::ProtocolMetatypeToProtocolClass:
+    return "[protocol-metatype-to-object]";
   case ConversionRestrictionKind::ForceUnchecked:
     return "[force-unchecked]";
   case ConversionRestrictionKind::ArrayUpcast:

lib/Sema/Constraint.h

@@ -149,6 +149,13 @@ enum class ConversionRestrictionKind {
   DeepEquality,
   /// Subclass-to-superclass conversion.
   Superclass,
+  /// Class metatype to AnyObject conversion.
+  ClassMetatypeToAnyObject,
+  /// Existential metatype to AnyObject conversion.
+  ExistentialMetatypeToAnyObject,
+  /// Protocol value metatype to Protocol class conversion.
+  ProtocolMetatypeToProtocolClass,
+  /// Existential metatype to AnyObject conversion.
   /// Lvalue-to-rvalue conversion.
   LValueToRValue,
   /// Value to existential value conversion.

lib/Sema/MiscDiagnostics.cpp

@@ -204,6 +204,9 @@ static void diagModuleOrMetatypeValue(TypeChecker &TC, const Expr *E) {
           case ExprKind::OpaqueValue:
           case ExprKind::BindOptional:
           case ExprKind::OptionalEvaluation:
+          case ExprKind::ClassMetatypeToObject:
+          case ExprKind::ProtocolMetatypeToObject:
+          case ExprKind::ExistentialMetatypeToObject:
           case ExprKind::ForceValue:
           case ExprKind::OpenExistential:
           case ExprKind::PrefixUnary:

test/ClangModules/protocol_metatype_object_conversion.swift

@@ -0,0 +1,16 @@
+// RUN: rm -rf %t/clang-module-cache
+// RUN: %swift %clang-importer-sdk -enable-metatype-object-conversions -parse -verify -module-cache-path %t/clang-module-cache -target x86_64-apple-darwin13 %s
+
+import ObjectiveC
+
+@objc protocol ObjCProto {}
+@objc protocol ObjCProto2 {}
+protocol NonObjCProto {}
+typealias TwoObjCProtos = protocol<ObjCProto, ObjCProto2>
+
+func takesProtocol(x: Protocol) {} // expected-note{{}} expected-note{{}}
+
+takesProtocol(ObjCProto.self)
+takesProtocol(ObjCProto2.self)
+takesProtocol(NonObjCProto.self) // expected-error{{'NonObjCProto.Protocol' is not convertible to 'Protocol'}}
+takesProtocol(TwoObjCProtos.self) // expected-error{{'TwoObjCProtos.Protocol' is not convertible to 'Protocol'}}

test/Parse/metatype_object_conversion.swift

@@ -0,0 +1,24 @@
+// RUN: %swift -enable-metatype-object-conversions -parse -verify %s
+
+class C {}
+struct S {}
+
+protocol NonClassProto {}
+@class_protocol protocol ClassConstrainedProto {}
+
+func takesAnyObject(x: AnyObject) {} // expected-note{{}} // expected-note{{}} // expected-note{{}}
+
+func concreteTypes() {
+  takesAnyObject(C.self) 
+  // TODO: Better error messages
+  takesAnyObject(S.self) // expected-error{{'S.Type' does not conform to protocol 'AnyObject'}}
+  takesAnyObject(ClassConstrainedProto.self) // expected-error{{'ClassConstrainedProto.Protocol' does not conform to protocol 'AnyObject'}}
+}
+
+func existentialMetatypes(nonClass: NonClassProto.Type,
+                          classConstrained: ClassConstrainedProto.Type,
+                          compo: protocol<NonClassProto, ClassConstrainedProto>.Type) {
+  takesAnyObject(nonClass) // expected-error{{'NonClassProto.Type' does not conform to protocol 'AnyObject'}}
+  takesAnyObject(classConstrained)
+  takesAnyObject(compo)
+}