Merge remote-tracking branch 'origin/master' into master-next

Author: swift-ci

include/swift/Runtime/Metadata.h

@@ -597,6 +597,14 @@ void swift_initClassMetadata(ClassMetadata *self,
                              const TypeLayout * const *fieldTypes,
                              size_t *fieldOffsets);
 
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+MetadataDependency
+swift_initClassMetadata2(ClassMetadata *self,
+                         ClassLayoutFlags flags,
+                         size_t numFields,
+                         const TypeLayout * const *fieldTypes,
+                         size_t *fieldOffsets);
+
 #if SWIFT_OBJC_INTEROP
 /// Initialize various fields of the class metadata.
 ///
@@ -612,6 +620,14 @@ void swift_updateClassMetadata(ClassMetadata *self,
                                size_t numFields,
                                const TypeLayout * const *fieldTypes,
                                size_t *fieldOffsets);
+
+SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+MetadataDependency
+swift_updateClassMetadata2(ClassMetadata *self,
+                           ClassLayoutFlags flags,
+                           size_t numFields,
+                           const TypeLayout * const *fieldTypes,
+                           size_t *fieldOffsets);
 #endif
 
 /// Given class metadata, a class descriptor and a method descriptor, look up

include/swift/Runtime/RuntimeFunctions.def

@@ -808,6 +808,34 @@ FUNCTION(UpdateClassMetadata,
               SizeTy->getPointerTo()),
          ATTRS(NoUnwind))
 
+// struct FieldInfo { size_t Size; size_t AlignMask; };
+// MetadataDependency swift_initClassMetadata2(Metadata *self,
+//                                             ClassLayoutFlags flags,
+//                                             size_t numFields,
+//                                             TypeLayout * const *fieldTypes,
+//                                             size_t *fieldOffsets);
+FUNCTION(InitClassMetadata2,
+         swift_initClassMetadata2, SwiftCC,
+         RETURNS(TypeMetadataDependencyTy),
+         ARGS(TypeMetadataPtrTy, SizeTy, SizeTy,
+              Int8PtrPtrTy->getPointerTo(),
+              SizeTy->getPointerTo()),
+         ATTRS(NoUnwind))
+
+// struct FieldInfo { size_t Size; size_t AlignMask; };
+// MetadataDependency swift_updateClassMetadata2(Metadata *self,
+//                                               ClassLayoutFlags flags,
+//                                               size_t numFields,
+//                                               TypeLayout * const *fieldTypes,
+//                                               size_t *fieldOffsets);
+FUNCTION(UpdateClassMetadata2,
+         swift_updateClassMetadata2, SwiftCC,
+         RETURNS(TypeMetadataDependencyTy),
+         ARGS(TypeMetadataPtrTy, SizeTy, SizeTy,
+              Int8PtrPtrTy->getPointerTo(),
+              SizeTy->getPointerTo()),
+         ATTRS(NoUnwind))
+
 // void *swift_lookUpClassMethod(Metadata *metadata,
 //                               ClassDescriptor *description,
 //                               MethodDescriptor *method);

lib/Sema/CSGen.cpp

@@ -1429,20 +1429,27 @@ namespace {
                           diag::super_with_no_base_class);
     }
 
-    Type resolveTypeReferenceInExpression(TypeRepr *rep) {
+    Type resolveTypeReferenceInExpression(TypeRepr *repr) {
+      TypeLoc loc(repr);
+      return resolveTypeReferenceInExpression(loc);
+    }
+
+    Type resolveTypeReferenceInExpression(TypeLoc &loc) {
       TypeResolutionOptions options(TypeResolverContext::InExpression);
       options |= TypeResolutionFlags::AllowUnboundGenerics;
-      return TypeResolution::forContextual(CS.DC).resolveType(rep,
-                                                              options);
+      bool hadError = CS.TC.validateType(
+          loc, TypeResolution::forContextual(CS.DC), options);
+      return hadError ? Type() : loc.getType();
     }
 
     Type visitTypeExpr(TypeExpr *E) {
       Type type;
       // If this is an implicit TypeExpr, don't validate its contents.
-      if (E->getTypeLoc().wasValidated()) {
-        type = E->getTypeLoc().getType();
-      } else if (auto *rep = E->getTypeRepr()) {
-        type = resolveTypeReferenceInExpression(rep);
+      auto &typeLoc = E->getTypeLoc();
+      if (typeLoc.wasValidated()) {
+        type = typeLoc.getType();
+      } else if (typeLoc.hasLocation()) {
+        type = resolveTypeReferenceInExpression(typeLoc);
       }
 
       if (!type || type->hasError()) return Type();

lib/Sema/TypeCheckPattern.cpp

@@ -773,13 +773,6 @@ static bool validateParameterType(ParamDecl *decl, TypeResolution resolution,
     }
   }
 
-  // If this parameter declaration is marked as `@autoclosure`
-  // let's make sure that its parameter type is indeed a function,
-  // this decision couldn't be made based on type representative
-  // alone because it may be later resolved into an invalid type.
-  if (decl->isAutoClosure())
-    hadError |= !(Ty && Ty->is<FunctionType>());
-
   if (hadError)
     TL.setInvalidType(TC.Context);