Merge pull request #940 from swiftwasm/master

[pull] swiftwasm from master

Author: pull[bot]

include/swift/AST/IndexSubset.h

@@ -207,7 +207,7 @@ class IndexSubset : public llvm::FoldingSetNode {
   }
 
   void print(llvm::raw_ostream &s = llvm::outs()) const;
-  SWIFT_DEBUG_DUMPER(dump(llvm::raw_ostream &s = llvm::errs()));
+  SWIFT_DEBUG_DUMPER(dump());
 
   int findNext(int startIndex) const;
   int findFirst() const { return findNext(-1); }

include/swift/SILOptimizer/Differentiation/Common.h

@@ -211,19 +211,16 @@ inline void createEntryArguments(SILFunction *f) {
     decl->setSpecifier(ParamDecl::Specifier::Default);
     entry->createFunctionArgument(type, decl);
   };
-  // f->getLoweredFunctionType()->remap
   for (auto indResTy :
        conv.getIndirectSILResultTypes(f->getTypeExpansionContext())) {
     if (indResTy.hasArchetype())
       indResTy = indResTy.mapTypeOutOfContext();
     createFunctionArgument(f->mapTypeIntoContext(indResTy).getAddressType());
-    // createFunctionArgument(indResTy.getAddressType());
   }
   for (auto paramTy : conv.getParameterSILTypes(f->getTypeExpansionContext())) {
     if (paramTy.hasArchetype())
       paramTy = paramTy.mapTypeOutOfContext();
     createFunctionArgument(f->mapTypeIntoContext(paramTy));
-    // createFunctionArgument(paramTy);
   }
 }
 

include/swift/SILOptimizer/Differentiation/PullbackEmitter.h

@@ -18,10 +18,10 @@
 #ifndef SWIFT_SILOPTIMIZER_UTILS_DIFFERENTIATION_PULLBACKEMITTER_H
 #define SWIFT_SILOPTIMIZER_UTILS_DIFFERENTIATION_PULLBACKEMITTER_H
 
+#include "swift/SILOptimizer/Analysis/DifferentiableActivityAnalysis.h"
 #include "swift/SILOptimizer/Differentiation/AdjointValue.h"
 #include "swift/SILOptimizer/Differentiation/DifferentiationInvoker.h"
 #include "swift/SILOptimizer/Differentiation/LinearMapInfo.h"
-#include "swift/SILOptimizer/Analysis/DifferentiableActivityAnalysis.h"
 
 #include "swift/SIL/TypeSubstCloner.h"
 #include "llvm/ADT/DenseMap.h"

include/swift/SILOptimizer/Differentiation/VJPEmitter.h

@@ -18,9 +18,9 @@
 #ifndef SWIFT_SILOPTIMIZER_UTILS_DIFFERENTIATION_VJPEMITTER_H
 #define SWIFT_SILOPTIMIZER_UTILS_DIFFERENTIATION_VJPEMITTER_H
 
+#include "swift/SILOptimizer/Analysis/DifferentiableActivityAnalysis.h"
 #include "swift/SILOptimizer/Differentiation/DifferentiationInvoker.h"
 #include "swift/SILOptimizer/Differentiation/LinearMapInfo.h"
-#include "swift/SILOptimizer/Analysis/DifferentiableActivityAnalysis.h"
 
 #include "swift/SIL/TypeSubstCloner.h"
 #include "llvm/ADT/DenseMap.h"

lib/AST/Decl.cpp

@@ -7111,10 +7111,19 @@ void AbstractFunctionDecl::prepareDerivativeFunctionConfigurations() {
 ArrayRef<AutoDiffConfig>
 AbstractFunctionDecl::getDerivativeFunctionConfigurations() {
   prepareDerivativeFunctionConfigurations();
+
   // Resolve derivative function configurations from `@differentiable`
   // attributes by type-checking them.
   for (auto *diffAttr : getAttrs().getAttributes<DifferentiableAttr>())
     (void)diffAttr->getParameterIndices();
+  // For accessors: resolve derivative function configurations from storage
+  // `@differentiable` attributes by type-checking them.
+  if (auto *accessor = dyn_cast<AccessorDecl>(this)) {
+    auto *storage = accessor->getStorage();
+    for (auto *diffAttr : storage->getAttrs().getAttributes<DifferentiableAttr>())
+      (void)diffAttr->getParameterIndices();
+  }
+
   // Load derivative configurations from imported modules.
   auto &ctx = getASTContext();
   if (ctx.getCurrentGeneration() > DerivativeFunctionConfigGeneration) {

lib/AST/GenericSignature.cpp

@@ -379,7 +379,8 @@ GenericSignatureImpl::lookupConformance(CanType type,
 }
 
 bool GenericSignatureImpl::requiresClass(Type type) {
-  if (!type->isTypeParameter()) return false;
+  assert(type->isTypeParameter() &&
+         "Only type parameters can have superclass requirements");
 
   auto &builder = *getGenericSignatureBuilder();
   auto equivClass =

lib/AST/IndexSubset.cpp

@@ -86,7 +86,8 @@ void IndexSubset::print(llvm::raw_ostream &s) const {
   s << '}';
 }
 
-void IndexSubset::dump(llvm::raw_ostream &s) const {
+void IndexSubset::dump() const {
+  auto &s = llvm::errs();
   s << "(index_subset capacity=" << capacity << " indices=(";
   interleave(getIndices(), [&s](unsigned i) { s << i; },
              [&s] { s << ", "; });

lib/SIL/IR/AbstractionPattern.cpp

@@ -222,8 +222,7 @@ bool AbstractionPattern::requiresClass() const {
     auto type = getType();
     if (auto archetype = dyn_cast<ArchetypeType>(type))
       return archetype->requiresClass();
-    if (isa<DependentMemberType>(type) ||
-        isa<GenericTypeParamType>(type)) {
+    if (type->isTypeParameter()) {
       if (getKind() == Kind::ClangType) {
         // ObjC generics are always class constrained.
         return true;

lib/SILOptimizer/Differentiation/LinearMapInfo.cpp

@@ -126,8 +126,8 @@ LinearMapInfo::createBranchingTraceDecl(SILBasicBlock *originalBB,
   auto originalFnTy = original->getLoweredFunctionType();
   auto numResults = originalFnTy->getNumResults() +
                     originalFnTy->getNumIndirectMutatingParameters();
-  auto *resultIndices = IndexSubset::get(
-      original->getASTContext(), numResults, indices.source);
+  auto *resultIndices =
+      IndexSubset::get(original->getASTContext(), numResults, indices.source);
   auto *parameterIndices = indices.parameters;
   AutoDiffConfig config(parameterIndices, resultIndices, genericSig);
   auto enumName = mangler.mangleAutoDiffGeneratedDeclaration(
@@ -199,8 +199,8 @@ LinearMapInfo::createLinearMapStruct(SILBasicBlock *originalBB,
   auto originalFnTy = original->getLoweredFunctionType();
   auto numResults = originalFnTy->getNumResults() +
                     originalFnTy->getNumIndirectMutatingParameters();
-  auto *resultIndices = IndexSubset::get(
-      original->getASTContext(), numResults, indices.source);
+  auto *resultIndices =
+      IndexSubset::get(original->getASTContext(), numResults, indices.source);
   auto *parameterIndices = indices.parameters;
   AutoDiffConfig config(parameterIndices, resultIndices, genericSig);
   auto structName = mangler.mangleAutoDiffGeneratedDeclaration(

lib/SILOptimizer/Differentiation/PullbackEmitter.cpp

@@ -151,8 +151,8 @@ void PullbackEmitter::cleanUpTemporariesForBlock(SILBasicBlock *bb,
 const Lowering::TypeLowering &PullbackEmitter::getTypeLowering(Type type) {
   auto pbGenSig =
       getPullback().getLoweredFunctionType()->getSubstGenericSignature();
-  Lowering::AbstractionPattern pattern(
-      pbGenSig, type->getCanonicalType(pbGenSig));
+  Lowering::AbstractionPattern pattern(pbGenSig,
+                                       type->getCanonicalType(pbGenSig));
   return getPullback().getTypeLowering(pattern, type);
 }
 
@@ -2083,8 +2083,8 @@ void PullbackEmitter::accumulateIndirect(SILValue lhsDestAccess,
   auto type = lhsDestAccess->getType();
   auto astType = type.getASTType();
   auto *swiftMod = getModule().getSwiftModule();
-  auto tangentSpace = astType->getAutoDiffTangentSpace(
-      LookUpConformanceInModule(swiftMod));
+  auto tangentSpace =
+      astType->getAutoDiffTangentSpace(LookUpConformanceInModule(swiftMod));
   assert(tangentSpace && "No tangent space for this type");
   switch (tangentSpace->getKind()) {
   case TangentSpace::Kind::TangentVector: {

lib/SILOptimizer/Differentiation/VJPEmitter.cpp

@@ -174,7 +174,8 @@ SILFunction *VJPEmitter::createEmptyPullback() {
     SILParameterInfo inoutParamTanParam(
         origResult.getInterfaceType()
             ->getAutoDiffTangentSpace(lookupConformance)
-            ->getType()->getCanonicalType(witnessCanGenSig),
+            ->getType()
+            ->getCanonicalType(witnessCanGenSig),
         inoutParamTanConvention);
     pbParams.push_back(inoutParamTanParam);
   } else {
@@ -184,15 +185,17 @@ SILFunction *VJPEmitter::createEmptyPullback() {
     pbParams.push_back(getTangentParameterInfoForOriginalResult(
         origResult.getInterfaceType()
             ->getAutoDiffTangentSpace(lookupConformance)
-            ->getType()->getCanonicalType(witnessCanGenSig),
+            ->getType()
+            ->getCanonicalType(witnessCanGenSig),
         origResult.getConvention()));
   }
 
   // Accept a pullback struct in the pullback parameter list. This is the
   // returned pullback's closure context.
   auto *origExit = &*original->findReturnBB();
   auto *pbStruct = pullbackInfo.getLinearMapStruct(origExit);
-  auto pbStructType = pbStruct->getDeclaredInterfaceType()->getCanonicalType(witnessCanGenSig);
+  auto pbStructType =
+      pbStruct->getDeclaredInterfaceType()->getCanonicalType(witnessCanGenSig);
   pbParams.push_back({pbStructType, ParameterConvention::Direct_Owned});
 
   // Add pullback results for the requested wrt parameters.
@@ -205,7 +208,8 @@ SILFunction *VJPEmitter::createEmptyPullback() {
     adjResults.push_back(getTangentResultInfoForOriginalParameter(
         origParam.getInterfaceType()
             ->getAutoDiffTangentSpace(lookupConformance)
-            ->getType()->getCanonicalType(witnessCanGenSig),
+            ->getType()
+            ->getCanonicalType(witnessCanGenSig),
         origParam.getConvention()));
   }
 
@@ -275,8 +279,8 @@ void VJPEmitter::visitSILInstruction(SILInstruction *inst) {
 
 SILType VJPEmitter::getLoweredType(Type type) {
   auto vjpGenSig = vjp->getLoweredFunctionType()->getSubstGenericSignature();
-  Lowering::AbstractionPattern pattern(
-      vjpGenSig, type->getCanonicalType(vjpGenSig));
+  Lowering::AbstractionPattern pattern(vjpGenSig,
+                                       type->getCanonicalType(vjpGenSig));
   return vjp->getLoweredType(pattern, type);
 }
 
@@ -490,9 +494,8 @@ void VJPEmitter::visitSwitchEnumInstBase(SwitchEnumInstBase *sei) {
                                   newDefaultBB, caseBBs);
     break;
   case SILInstructionKind::SwitchEnumAddrInst:
-    getBuilder().createSwitchEnumAddr(sei->getLoc(),
-                                      getOpValue(sei->getOperand()),
-                                      newDefaultBB, caseBBs);
+    getBuilder().createSwitchEnumAddr(
+        sei->getLoc(), getOpValue(sei->getOperand()), newDefaultBB, caseBBs);
     break;
   default:
     llvm_unreachable("Expected `switch_enum` or `switch_enum_addr`");

lib/SILOptimizer/Mandatory/Differentiation.cpp

@@ -656,9 +656,9 @@ emitDerivativeFunctionReference(
     auto loc = witnessMethod->getLoc();
     auto requirementDeclRef = witnessMethod->getMember();
     auto *requirementDecl = requirementDeclRef.getAbstractFunctionDecl();
-    // If requirement declaration does not have any `@differentiable`
-    // attributes, produce an error.
-    if (!requirementDecl->getAttrs().hasAttribute<DifferentiableAttr>()) {
+    // If requirement declaration does not have any derivative function
+    // configurations, produce an error.
+    if (requirementDecl->getDerivativeFunctionConfigurations().empty()) {
       context.emitNondifferentiabilityError(
           original, invoker, diag::autodiff_protocol_member_not_differentiable);
       return None;
@@ -701,9 +701,9 @@ emitDerivativeFunctionReference(
     auto loc = classMethod->getLoc();
     auto methodDeclRef = classMethod->getMember();
     auto *methodDecl = methodDeclRef.getAbstractFunctionDecl();
-    // If method declaration does not have any `@differentiable` attributes,
-    // produce an error.
-    if (!methodDecl->getAttrs().hasAttribute<DifferentiableAttr>()) {
+    // If method declaration does not have any derivative function
+    // configurations, produce an error.
+    if (methodDecl->getDerivativeFunctionConfigurations().empty()) {
       context.emitNondifferentiabilityError(
           original, invoker, diag::autodiff_class_member_not_differentiable);
       return None;

lib/Sema/TypeCheckPattern.cpp

@@ -467,9 +467,7 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
     auto *repr = IdentTypeRepr::create(Context, components);
 
     // See if the repr resolves to a type.
-    Type ty = TypeChecker::resolveIdentifierType(
-        TypeResolution::forContextual(DC, options), repr);
-
+    auto ty = TypeResolution::forContextual(DC, options).resolveType(repr);
     auto *enumDecl = dyn_cast_or_null<EnumDecl>(ty->getAnyNominal());
     if (!enumDecl)
       return nullptr;
@@ -566,8 +564,8 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
       auto *prefixRepr = IdentTypeRepr::create(Context, components);
 
       // See first if the entire repr resolves to a type.
-      Type enumTy = TypeChecker::resolveIdentifierType(
-          TypeResolution::forContextual(DC, options), prefixRepr);
+      Type enumTy = TypeResolution::forContextual(DC, options)
+                        .resolveType(prefixRepr);
       if (!dyn_cast_or_null<EnumDecl>(enumTy->getAnyNominal()))
         return nullptr;
 

lib/Sema/TypeCheckType.cpp

@@ -1632,60 +1632,6 @@ static Type applyNonEscapingFromContext(DeclContext *DC,
   return ty;
 }
 
-/// Returns a valid type or ErrorType in case of an error.
-Type TypeChecker::resolveIdentifierType(TypeResolution resolution,
-                                        IdentTypeRepr *IdType) {
-  const auto options = resolution.getOptions();
-  auto DC = resolution.getDeclContext();
-  ASTContext &ctx = DC->getASTContext();
-  auto &diags = ctx.Diags;
-  auto ComponentRange = IdType->getComponentRange();
-  auto Components = llvm::makeArrayRef(ComponentRange.begin(),
-                                       ComponentRange.end());
-  Type result = resolveIdentTypeComponent(resolution, Components);
-  if (!result) return nullptr;
-
-  if (auto moduleTy = result->getAs<ModuleType>()) {
-    // Allow module types only if flag is specified.
-    if (options.contains(TypeResolutionFlags::AllowModule))
-      return moduleTy;
-    // Otherwise, emit an error.
-    if (!options.contains(TypeResolutionFlags::SilenceErrors)) {
-      auto moduleName = moduleTy->getModule()->getName();
-      diags.diagnose(Components.back()->getNameLoc(),
-                     diag::cannot_find_type_in_scope, DeclNameRef(moduleName));
-      diags.diagnose(Components.back()->getNameLoc(),
-                     diag::note_module_as_type, moduleName);
-    }
-    Components.back()->setInvalid();
-    return ErrorType::get(ctx);
-  }
-
-  // Hack to apply context-specific @escaping to a typealias with an underlying
-  // function type.
-  if (result->is<FunctionType>())
-    result = applyNonEscapingFromContext(DC, result, options);
-
-  // Check the availability of the type.
-
-  // We allow a type to conform to a protocol that is less available than
-  // the type itself. This enables a type to retroactively model or directly
-  // conform to a protocol only available on newer OSes and yet still be used on
-  // older OSes.
-  // To support this, inside inheritance clauses we allow references to
-  // protocols that are unavailable in the current type refinement context.
-
-  if (!options.contains(TypeResolutionFlags::SilenceErrors) &&
-      !options.contains(TypeResolutionFlags::AllowUnavailable) &&
-      diagnoseAvailability(IdType, DC,
-             options.contains(TypeResolutionFlags::AllowUnavailableProtocol))) {
-    Components.back()->setInvalid();
-    return ErrorType::get(ctx);
-  }
-  
-  return result;
-}
-
 /// Validate whether type associated with @autoclosure attribute is correct,
 /// it supposed to be a function type with no parameters.
 /// \returns true if there was an error, false otherwise.
@@ -1831,6 +1777,8 @@ namespace {
                                 SmallVectorImpl<SILYieldInfo> &yields,
                                 SmallVectorImpl<SILResultInfo> &results,
                                 Optional<SILResultInfo> &errorResult);
+    Type resolveIdentifierType(IdentTypeRepr *IdType,
+                               TypeResolutionOptions options);
     Type resolveSpecifierTypeRepr(SpecifierTypeRepr *repr,
                                   TypeResolutionOptions options);
     Type resolveArrayType(ArrayTypeRepr *repr,
@@ -1949,8 +1897,7 @@ Type TypeResolver::resolveType(TypeRepr *repr, TypeResolutionOptions options) {
   case TypeReprKind::SimpleIdent:
   case TypeReprKind::GenericIdent:
   case TypeReprKind::CompoundIdent:
-    return TypeChecker::resolveIdentifierType(resolution.withOptions(options),
-                                              cast<IdentTypeRepr>(repr));
+    return resolveIdentifierType(cast<IdentTypeRepr>(repr), options);
 
   case TypeReprKind::Function: {
     if (!(options & TypeResolutionFlags::SILType)) {
@@ -3258,6 +3205,56 @@ bool TypeResolver::resolveSILResults(TypeRepr *repr,
                                 yields, ordinaryResults, errorResult);
 }
 
+Type TypeResolver::resolveIdentifierType(IdentTypeRepr *IdType,
+                                         TypeResolutionOptions options) {
+  auto ComponentRange = IdType->getComponentRange();
+  auto Components = llvm::makeArrayRef(ComponentRange.begin(),
+                                       ComponentRange.end());
+  Type result = resolveIdentTypeComponent(resolution.withOptions(options),
+                                          Components);
+  if (!result) return nullptr;
+
+  if (auto moduleTy = result->getAs<ModuleType>()) {
+    // Allow module types only if flag is specified.
+    if (options.contains(TypeResolutionFlags::AllowModule))
+      return moduleTy;
+    // Otherwise, emit an error.
+    if (!options.contains(TypeResolutionFlags::SilenceErrors)) {
+      auto moduleName = moduleTy->getModule()->getName();
+      diagnose(Components.back()->getNameLoc(),
+               diag::cannot_find_type_in_scope, DeclNameRef(moduleName));
+      diagnose(Components.back()->getNameLoc(),
+               diag::note_module_as_type, moduleName);
+    }
+    Components.back()->setInvalid();
+    return ErrorType::get(Context);
+  }
+
+  // Hack to apply context-specific @escaping to a typealias with an underlying
+  // function type.
+  if (result->is<FunctionType>())
+    result = applyNonEscapingFromContext(DC, result, options);
+
+  // Check the availability of the type.
+
+  // We allow a type to conform to a protocol that is less available than
+  // the type itself. This enables a type to retroactively model or directly
+  // conform to a protocol only available on newer OSes and yet still be used on
+  // older OSes.
+  // To support this, inside inheritance clauses we allow references to
+  // protocols that are unavailable in the current type refinement context.
+
+  if (!options.contains(TypeResolutionFlags::SilenceErrors) &&
+      !options.contains(TypeResolutionFlags::AllowUnavailable) &&
+      diagnoseAvailability(IdType, DC,
+             options.contains(TypeResolutionFlags::AllowUnavailableProtocol))) {
+    Components.back()->setInvalid();
+    return ErrorType::get(Context);
+  }
+
+  return result;
+}
+
 Type TypeResolver::resolveSpecifierTypeRepr(SpecifierTypeRepr *repr,
                                             TypeResolutionOptions options) {
   // inout is only valid for (non-Subscript and non-EnumCaseDecl)