Fix static member functions so a member of type T has type "metatype<T> -> () -> ()" instead of "() -> ()".

This is much more convenient for IRGen, and gives us a reasonable representation for a static
polymorphic function on a polymorphic type.

I had to hack up irgen::emitArrayInjectionCall a bit to make the rest of this patch work; John, please
revert those bits once emitCallee is fixed.



Swift SVN r2488

Author: Eli Friedman

include/swift/AST/Expr.h

@@ -1266,6 +1266,19 @@ class SpecializeExpr : public ImplicitConversionExpr {
   }
 };
 
+/// GetMetatypeExpr - 
+class GetMetatypeExpr : public ImplicitConversionExpr {
+public:
+  GetMetatypeExpr(Expr *subExpr, Type type)
+    : ImplicitConversionExpr(ExprKind::GetMetatype, subExpr, type) {}
+
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const LoadExpr *) { return true; }
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::GetMetatype;
+  }
+};
+
 /// AddressOfExpr - Using the builtin unary '&' operator, convert the
 /// given l-value into an explicit l-value.
 class AddressOfExpr : public Expr {

include/swift/AST/ExprNodes.def

@@ -106,7 +106,8 @@ ABSTRACT_EXPR(ImplicitConversion, Expr)
   EXPR(FunctionConversion, ImplicitConversionExpr)
   EXPR(Erasure, ImplicitConversionExpr)
   EXPR(Specialize, ImplicitConversionExpr)
-  EXPR_RANGE(ImplicitConversion, Load, Specialize)
+  EXPR(GetMetatype, ImplicitConversionExpr)
+  EXPR_RANGE(ImplicitConversion, Load, GetMetatype)
 EXPR(Coerce, Expr)
 
 #undef EXPR_RANGE

lib/AST/Decl.cpp

@@ -453,19 +453,6 @@ Type FuncDecl::getExtensionType() const {
 Type FuncDecl::computeThisType(GenericParamList **OuterGenericParams) const {
   if (OuterGenericParams)
     *OuterGenericParams = nullptr;
-
-  // 'static' functions have no 'this' argument.
-  if (isStatic()) {
-    if (OuterGenericParams) {
-      if (Type containerType = getExtensionType()) {
-        if (auto UGT = containerType->getAs<UnboundGenericType>()) {
-          *OuterGenericParams = UGT->getDecl()->getGenericParams();
-        }
-      }
-    }
-    
-    return Type();
-  }
 
   Type ContainerType = getExtensionType();
   if (ContainerType.isNull()) return ContainerType;
@@ -503,6 +490,10 @@ Type FuncDecl::computeThisType(GenericParamList **OuterGenericParams) const {
       *OuterGenericParams = D->getGenericParams();
   }
 
+  // 'static' functions have 'this' of type metatype<T>.
+  if (isStatic())
+    return MetaTypeType::get(ContainerType, getASTContext());
+
   if (ContainerType->hasReferenceSemantics())
     return ContainerType;
 
@@ -515,8 +506,6 @@ Type FuncDecl::computeThisType(GenericParamList **OuterGenericParams) const {
 /// extension context, it will have a 'this' argument.  This method returns it
 /// if present, or returns null if not.
 VarDecl *FuncDecl::getImplicitThisDecl() {
-  if (isStatic()) return 0;
-  
   if (Body->getParamPatterns().empty()) return 0;
 
   // "this" is represented as (typed_pattern (named_pattern (var_decl 'this')).

lib/AST/Expr.cpp

@@ -150,15 +150,9 @@ ArchetypeType *ArchetypeMemberRefExpr::getArchetype() const {
 }
 
 bool ArchetypeMemberRefExpr::isBaseIgnored() const {
-  if (getBase()->getType()->getRValueType()->is<MetaTypeType>())
-    return true;
-
   if (isa<TypeDecl>(Value))
     return true;
 
-  if (auto Func = dyn_cast<FuncDecl>(Value))
-    return Func->isStatic();
-
   return false;
 }
 
@@ -595,6 +589,11 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     printRec(E->getSubExpr());
     OS << ')';
   }
+  void visitGetMetatypeExpr(GetMetatypeExpr *E) {
+    printCommon(E, "get_metatype_expr") << '\n';
+    printRec(E->getSubExpr());
+    OS << ')';
+  }
 
   void visitAddressOfExpr(AddressOfExpr *E) {
     printCommon(E, "address_of_expr") << '\n';

lib/AST/Verifier.cpp

@@ -283,7 +283,8 @@ namespace {
         if (isa<ThisApplyExpr>(E)) {
           LValueType::Qual InputExprQuals;
           Type InputExprObjectTy;
-          if (InputExprTy->hasReferenceSemantics())
+          if (InputExprTy->hasReferenceSemantics() ||
+              InputExprTy->is<MetaTypeType>())
             InputExprObjectTy = InputExprTy;
           else
             InputExprObjectTy = checkLValue(InputExprTy, InputExprQuals,

lib/IRGen/GenArray.cpp

@@ -132,8 +132,22 @@ void swift::irgen::emitArrayInjectionCall(IRGenFunction &IGF, ManagedValue alloc
 
   // Emit the callee.
   llvm::SmallVector<Arg, 4> args;
+  // FIXME: emitCallee is currently broken; use an ugly workaround in the
+  // meantime.
+#if 0
   Callee callee =
     emitCallee(IGF, injectionFn, out.getKind(), /*uncurry*/ 0, args);
+#else
+  Explosion CalleeExplosion(ExplosionKind::Minimal);
+  IGF.emitRValue(injectionFn, CalleeExplosion);
+  llvm::Value *fn = CalleeExplosion.claimUnmanagedNext();
+  llvm::Type *fnTy = IGF.IGM.getFunctionType(injectionFn->getType(),
+                                             ExplosionKind::Minimal, 0, true);
+  fn = IGF.Builder.CreateBitCast(fn, fnTy->getPointerTo());
+  ManagedValue data = CalleeExplosion.claimNext();
+  Callee callee = Callee::forIndirectCall(injectionFn->getType(), sliceTy,
+                                          ArrayRef<Substitution>(), fn, data);
+#endif
 
   // The injection function takes this tuple:
   //   (Builtin.RawPointer, Builtin.ObjectPointer, typeof(length))

lib/IRGen/GenExpr.cpp

@@ -300,6 +300,9 @@ namespace {
       IGF.unimplemented(E->getLoc(), "specialize expressions");
       IGF.emitFakeExplosion(IGF.getFragileTypeInfo(E->getType()), Out);
     }
+    void visitGetMetatypeExpr(GetMetatypeExpr *E) {
+      IGF.emitIgnored(E->getSubExpr());
+    }
     void visitTupleElementExpr(TupleElementExpr *E) {
       emitTupleElement(IGF, E, Out);
     }
@@ -462,6 +465,7 @@ namespace {
     NOT_LVALUE_EXPR(TupleShuffle)
     NOT_LVALUE_EXPR(Erasure)
     NOT_LVALUE_EXPR(Specialize) // FIXME: Generic subscripts?
+    NOT_LVALUE_EXPR(GetMetatype)
     NOT_LVALUE_EXPR(Func)
     NOT_LVALUE_EXPR(Closure)
     NOT_LVALUE_EXPR(Load)
@@ -646,6 +650,7 @@ namespace {
     NON_LOCATEABLE(TupleShuffleExpr)
     NON_LOCATEABLE(ErasureExpr)
     NON_LOCATEABLE(SpecializeExpr) // FIXME: Generic subscripts?
+    NON_LOCATEABLE(GetMetatypeExpr)
     NON_LOCATEABLE(CapturingExpr)
     NON_LOCATEABLE(ModuleExpr)
     NON_LOCATEABLE(DotSyntaxBaseIgnoredExpr)

lib/IRGen/GenFunc.cpp

@@ -1646,10 +1646,13 @@ static bool emitKnownCall(IRGenFunction &IGF, FuncDecl *Fn,
         name != "Float" && name != "Double")
       return false;
 
-    Expr *arg = callSites[0].getArg();
+    if (callSites.size() != 2)
+      return false;
+
+    Expr *arg = callSites[1].getArg();
     Explosion &out = result.initForDirectValues(ExplosionKind::Maximal);
     ExplosionSchema schema =
-      IGF.IGM.getSchema(callSites[0].getSubstResultType(), out.getKind());
+      IGF.IGM.getSchema(callSites[1].getSubstResultType(), out.getKind());
     assert(schema.size() == 1);
     llvm::Type *outTy = schema.begin()->getScalarType();
     if (isa<llvm::IntegerType>(outTy)) {
@@ -1675,7 +1678,10 @@ static bool emitKnownCall(IRGenFunction &IGF, FuncDecl *Fn,
     if (name != "Float" && name != "Double")
       return false;
 
-    Expr *arg = callSites[0].getArg();
+    if (callSites.size() != 2)
+      return false;
+
+    Expr *arg = callSites[1].getArg();
     Explosion &out = result.initForDirectValues(ExplosionKind::Maximal);
     IGF.emitRValue(arg, out);
     return true;

lib/IRGen/GenProto.cpp

@@ -2279,7 +2279,7 @@ namespace {
 
     void addStaticMethod(FuncDecl *iface) {
       FuncDecl *impl = cast<FuncDecl>(Conformance.Mapping.find(iface)->second);
-      Table.push_back(getStaticMethodWitness(impl, iface->getType()));
+      Table.push_back(getInstanceMethodWitness(impl, iface->getType()));
     }
 
     void addInstanceMethod(FuncDecl *iface) {
@@ -2295,12 +2295,6 @@ namespace {
       return getWitness(implPtr, impl->getType(), ifaceType, 1);
     }
 
-    llvm::Constant *getStaticMethodWitness(FuncDecl *impl, Type ifaceType) {
-      llvm::Constant *implPtr =
-        IGM.getAddrOfFunction(impl, ExplosionKind::Minimal, 0, /*data*/ false);
-      return getWitness(implPtr, impl->getType(), ifaceType, 0);
-    }
-
     llvm::Constant *getWitness(llvm::Constant *fn, Type fnTy, Type ifaceTy,
                                unsigned uncurryLevel) {
       return WitnessBuilder(IGM, fn, fnTy, ifaceTy, uncurryLevel).get();

lib/IRGen/Mangle.cpp

@@ -297,8 +297,6 @@ void Mangler::mangleType(Type type, ExplosionKind explosion,
   case TypeKind::UnboundGeneric:
     llvm_unreachable("mangling unresolved type");
 
-  case TypeKind::MetaType:
-    llvm_unreachable("Cannot mangle metatype yet");
   case TypeKind::Module:
     llvm_unreachable("Cannot mangle module type yet");
 
@@ -334,6 +332,11 @@ void Mangler::mangleType(Type type, ExplosionKind explosion,
 #define TYPE(id, parent)
 #include "swift/AST/TypeNodes.def"
 
+  case TypeKind::MetaType:
+    Buffer << 'M';
+    return mangleType(cast<MetaTypeType>(base)->getInstanceType(),
+                      ExplosionKind::Minimal, 0);
+
   case TypeKind::LValue:
     Buffer << 'R';
     return mangleType(cast<LValueType>(base)->getObjectType(),

lib/IRGen/OptimizeARC.cpp

@@ -1101,6 +1101,9 @@ static bool performARCExpansion(Function &F) {
         CI.setTailCall(true);
         Inst.eraseFromParent();
 
+        if (!isa<Instruction>(ArgVal))
+          continue;
+
         TinyPtrVector<Instruction*> &GlobalEntry = DefsOfValue[ArgVal];
 
         // If this is the first definition of a value for the argument that

lib/Parse/ParseDecl.cpp

@@ -1135,7 +1135,7 @@ FuncDecl *Parser::parseDeclFunc(bool hasContainerType) {
   // [byref] FooTy)->((int)->int)".  Note that we can't actually compute the
   // type here until Sema.
   bool hasImplicitThis = false;
-  if (hasContainerType && !StaticLoc.isValid() && !Name.isOperator()) {
+  if (hasContainerType) {
     Params.push_back(buildImplicitThisParameter());
     hasImplicitThis = true;
   }

lib/Sema/TypeCheckCoercion.cpp

@@ -449,9 +449,16 @@ class SemaCoerce : public ExprVisitor<SemaCoerce, CoercedResult> {
     // If it does, then everything is good, resolve the reference.
     if (!(Flags & CF_Apply))
       return DED->getType();
-    
-    return coerced(new (TC.Context) DeclRefExpr(DED, UME->getColonLoc(),
-                                                DED->getType()));
+
+    if (!DED->hasArgumentType()) {
+      return coerced(new (TC.Context) DeclRefExpr(DED, UME->getColonLoc(),
+                                                  DED->getType()));
+    }
+
+    Expr *E = new (TC.Context) TypeOfExpr(UME->getColonLoc(),
+                                          MetaTypeType::get(DT, TC.Context));
+    E = TC.buildMemberRefExpr(E, SourceLoc(), DED, UME->getColonLoc());
+    return coerced(TC.recheckTypes(E));
   }  
 
   CoercedResult visitParenExpr(ParenExpr *E) {
@@ -679,9 +686,8 @@ SemaCoerce::isLiteralCompatibleType(Type Ty, SourceLoc Loc, LiteralType LitTy) {
 
   // Check that the type of the 'convertFrom*Literal' method makes
   // sense.  We want a type of "S -> DestTy" where S is the expected type.
-  AnyFunctionType *FT = cast<AnyFunctionType>(Method->getType());
-
-  // FIXME: PolymorphicFunctionType?
+  AnyFunctionType *FT = Method->getType()->castTo<AnyFunctionType>();
+  FT = FT->getResult()->castTo<AnyFunctionType>();
 
   // The result of the convert function must be the destination type.
   if (!FT->getResult()->isEqual(Ty)) {
@@ -891,13 +897,12 @@ CoercedResult SemaCoerce::visitLiteralExpr(LiteralExpr *E) {
 
   if (!(Flags & CF_Apply))
     return DestTy;
-  
-  DeclRefExpr *DRE
-    = new (TC.Context) DeclRefExpr(Method,
-                                   // FIXME: This location is a hack!
-                                   Intermediate->getStartLoc(),
-                                   Method->getType());
-  
+
+  Expr *DRE = new (TC.Context) TypeOfExpr(Intermediate->getStartLoc(),
+                                          Method->computeThisType());
+  DRE = TC.recheckTypes(TC.buildMemberRefExpr(DRE, SourceLoc(), Method,
+                                              Intermediate->getStartLoc()));
+
   // Return a new call of the conversion function, passing in the integer
   // literal.
   return coerced(new (TC.Context) CallExpr(DRE, Intermediate, DestTy));
@@ -1708,7 +1713,7 @@ SemaCoerce::coerceObjectArgument(Expr *E, Type ContainerTy, CoercionContext &CC,
     return nullptr;
   }
 
-  if (SrcObjectTy->hasReferenceSemantics()) {
+  if (SrcObjectTy->hasReferenceSemantics() || SrcObjectTy->is<MetaTypeType>()) {
     // The destination type is just the source object type.
     if (!(Flags & CF_Apply))
       return SrcObjectTy;

lib/Sema/TypeCheckDecl.cpp

@@ -577,9 +577,13 @@ void DeclChecker::validateAttributes(ValueDecl *VD) {
 
   // Get the number of lexical arguments, for semantic checks below.
   int NumArguments = -1;
-  if (AnyFunctionType *FT = dyn_cast<AnyFunctionType>(Ty))
+  if (AnyFunctionType *FT = dyn_cast<AnyFunctionType>(Ty)) {
+    if (isa<FuncDecl>(VD) && VD->getDeclContext()->isTypeContext() &&
+        cast<FuncDecl>(VD)->isStatic())
+      FT = FT->getResult()->castTo<AnyFunctionType>();
     if (TupleType *TT = dyn_cast<TupleType>(FT->getInput()))
       NumArguments = TT->getFields().size();
+  }
 
   bool isOperator = VD->isOperator();