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

swift-ci · swift-ci · commit ce17c9b49358 · 2020-08-18T20:44:01.000-07:00
diff --git a/include/swift/AST/ModuleLoader.h b/include/swift/AST/ModuleLoader.h
@@ -24,6 +24,7 @@
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/TinyPtrVector.h"
 #include "swift/AST/ModuleDependencies.h"
+#include <system_error>
 
 namespace llvm {
 class FileCollector;
@@ -103,17 +104,18 @@ struct SubCompilerInstanceInfo {
 
 /// Abstract interface to run an action in a sub ASTContext.
 struct InterfaceSubContextDelegate {
-  virtual bool runInSubContext(StringRef moduleName,
-                               StringRef interfacePath,
-                               StringRef outputPath,
-                               SourceLoc diagLoc,
-  llvm::function_ref<bool(ASTContext&, ModuleDecl*, ArrayRef<StringRef>,
-                          ArrayRef<StringRef>, StringRef)> action) = 0;
-  virtual bool runInSubCompilerInstance(StringRef moduleName,
-                                        StringRef interfacePath,
-                                        StringRef outputPath,
-                                        SourceLoc diagLoc,
-                    llvm::function_ref<bool(SubCompilerInstanceInfo&)> action) = 0;
+  virtual std::error_code runInSubContext(StringRef moduleName,
+                                          StringRef interfacePath,
+                                          StringRef outputPath,
+                                          SourceLoc diagLoc,
+    llvm::function_ref<std::error_code(ASTContext&, ModuleDecl*,
+                                       ArrayRef<StringRef>,
+                                       ArrayRef<StringRef>, StringRef)> action) = 0;
+  virtual std::error_code runInSubCompilerInstance(StringRef moduleName,
+                                                   StringRef interfacePath,
+                                                   StringRef outputPath,
+                                                   SourceLoc diagLoc,
+    llvm::function_ref<std::error_code(SubCompilerInstanceInfo&)> action) = 0;
 
   virtual ~InterfaceSubContextDelegate() = default;
 };
diff --git a/include/swift/Frontend/ModuleInterfaceLoader.h b/include/swift/Frontend/ModuleInterfaceLoader.h
@@ -415,17 +415,18 @@ struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
                                   StringRef prebuiltCachePath,
                                   bool serializeDependencyHashes,
                                   bool trackSystemDependencies);
-  bool runInSubContext(StringRef moduleName,
-                       StringRef interfacePath,
-                       StringRef outputPath,
-                       SourceLoc diagLoc,
-    llvm::function_ref<bool(ASTContext&, ModuleDecl*, ArrayRef<StringRef>,
-                            ArrayRef<StringRef>, StringRef)> action) override;
-  bool runInSubCompilerInstance(StringRef moduleName,
-                                StringRef interfacePath,
-                                StringRef outputPath,
-                                SourceLoc diagLoc,
-            llvm::function_ref<bool(SubCompilerInstanceInfo&)> action) override;
+  std::error_code runInSubContext(StringRef moduleName,
+                                  StringRef interfacePath,
+                                  StringRef outputPath,
+                                  SourceLoc diagLoc,
+    llvm::function_ref<std::error_code(ASTContext&, ModuleDecl*,
+                                       ArrayRef<StringRef>, ArrayRef<StringRef>,
+                                       StringRef)> action) override;
+  std::error_code runInSubCompilerInstance(StringRef moduleName,
+                                           StringRef interfacePath,
+                                           StringRef outputPath,
+                                           SourceLoc diagLoc,
+    llvm::function_ref<std::error_code(SubCompilerInstanceInfo&)> action) override;
 
   ~InterfaceSubContextDelegateImpl() = default;
 
diff --git a/lib/Frontend/ModuleInterfaceBuilder.cpp b/lib/Frontend/ModuleInterfaceBuilder.cpp
@@ -161,10 +161,10 @@ bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
       llvm::RestorePrettyStackState(savedInnerPrettyStackState);
     };
 
-    SubError = subASTDelegate.runInSubCompilerInstance(moduleName,
-                                                       interfacePath,
-                                                       OutPath,
-                                                       diagnosticLoc,
+    SubError = (bool)subASTDelegate.runInSubCompilerInstance(moduleName,
+                                                             interfacePath,
+                                                             OutPath,
+                                                             diagnosticLoc,
                                            [&](SubCompilerInstanceInfo &info) {
     auto &SubInstance = *info.Instance;
     auto subInvocation = SubInstance.getInvocation();
@@ -173,7 +173,7 @@ bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
         .getModuleInterfaceLoader())->tryEmitForwardingModule(moduleName,
                                                               interfacePath,
                                                   CompiledCandidates, OutPath)) {
-      return false;
+      return std::error_code();
     }
     FrontendOptions &FEOpts = subInvocation.getFrontendOptions();
     const auto &InputInfo = FEOpts.InputsAndOutputs.firstInput();
@@ -208,7 +208,7 @@ bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
     SubInstance.performSema();
     if (SubInstance.getASTContext().hadError()) {
       LLVM_DEBUG(llvm::dbgs() << "encountered errors\n");
-      return true;
+      return std::make_error_code(std::errc::not_supported);
     }
 
     SILOptions &SILOpts = subInvocation.getSILOptions();
@@ -217,7 +217,7 @@ bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
     auto SILMod = performASTLowering(Mod, TC, SILOpts);
     if (!SILMod) {
       LLVM_DEBUG(llvm::dbgs() << "SILGen did not produce a module\n");
-      return true;
+      return std::make_error_code(std::errc::not_supported);
     }
 
     // Setup the callbacks for serialization, which can occur during the
@@ -237,7 +237,7 @@ bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
     SmallVector<FileDependency, 16> Deps;
     bool serializeHashes = FEOpts.SerializeModuleInterfaceDependencyHashes;
     if (collectDepsForSerialization(SubInstance, Deps, serializeHashes)) {
-      return true;
+      return std::make_error_code(std::errc::not_supported);
     }
     if (ShouldSerializeDeps)
       SerializationOpts.Dependencies = Deps;
@@ -253,9 +253,12 @@ bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
     LLVM_DEBUG(llvm::dbgs() << "Running SIL processing passes\n");
     if (SubInstance.performSILProcessing(SILMod.get())) {
       LLVM_DEBUG(llvm::dbgs() << "encountered errors\n");
-      return true;
+      return std::make_error_code(std::errc::not_supported);
+    }
+    if (SubInstance.getDiags().hadAnyError()) {
+      return std::make_error_code(std::errc::not_supported);
     }
-    return SubInstance.getDiags().hadAnyError();
+    return std::error_code();
     });
   });
   return !RunSuccess || SubError;
diff --git a/lib/Frontend/ModuleInterfaceLoader.cpp b/lib/Frontend/ModuleInterfaceLoader.cpp
@@ -1393,11 +1393,12 @@ InterfaceSubContextDelegateImpl::getCacheHash(StringRef useInterfacePath) {
   return llvm::APInt(64, H).toString(36, /*Signed=*/false);
 }
 
-bool InterfaceSubContextDelegateImpl::runInSubContext(StringRef moduleName,
-                                                      StringRef interfacePath,
-                                                      StringRef outputPath,
-                                                      SourceLoc diagLoc,
-    llvm::function_ref<bool(ASTContext&, ModuleDecl*, ArrayRef<StringRef>,
+std::error_code
+InterfaceSubContextDelegateImpl::runInSubContext(StringRef moduleName,
+                                                 StringRef interfacePath,
+                                                 StringRef outputPath,
+                                                 SourceLoc diagLoc,
+    llvm::function_ref<std::error_code(ASTContext&, ModuleDecl*, ArrayRef<StringRef>,
                             ArrayRef<StringRef>, StringRef)> action) {
   return runInSubCompilerInstance(moduleName, interfacePath, outputPath, diagLoc,
                                   [&](SubCompilerInstanceInfo &info){
@@ -1409,11 +1410,12 @@ bool InterfaceSubContextDelegateImpl::runInSubContext(StringRef moduleName,
   });
 }
 
-bool InterfaceSubContextDelegateImpl::runInSubCompilerInstance(StringRef moduleName,
-                                                               StringRef interfacePath,
-                                                               StringRef outputPath,
-                                                               SourceLoc diagLoc,
-                  llvm::function_ref<bool(SubCompilerInstanceInfo&)> action) {
+std::error_code
+InterfaceSubContextDelegateImpl::runInSubCompilerInstance(StringRef moduleName,
+                                                          StringRef interfacePath,
+                                                          StringRef outputPath,
+                                                          SourceLoc diagLoc,
+                  llvm::function_ref<std::error_code(SubCompilerInstanceInfo&)> action) {
   // We are about to mess up the compiler invocation by using the compiler
   // arguments in the textual interface file. So copy to use a new compiler
   // invocation.
@@ -1457,12 +1459,12 @@ bool InterfaceSubContextDelegateImpl::runInSubCompilerInstance(StringRef moduleN
                                           CompilerVersion,
                                           interfacePath,
                                           diagLoc)) {
-    return true;
+    return std::make_error_code(std::errc::not_supported);
   }
   // Insert arguments collected from the interface file.
   BuildArgs.insert(BuildArgs.end(), SubArgs.begin(), SubArgs.end());
   if (subInvocation.parseArgs(SubArgs, Diags)) {
-    return true;
+    return std::make_error_code(std::errc::not_supported);
   }
   CompilerInstance subInstance;
   SubCompilerInstanceInfo info;
@@ -1474,7 +1476,7 @@ bool InterfaceSubContextDelegateImpl::runInSubCompilerInstance(StringRef moduleN
   ForwardingDiagnosticConsumer FDC(Diags);
   subInstance.addDiagnosticConsumer(&FDC);
   if (subInstance.setup(subInvocation)) {
-    return true;
+    return std::make_error_code(std::errc::not_supported);
   }
   info.BuildArguments = BuildArgs;
   info.Hash = CacheHash;
diff --git a/lib/SILOptimizer/Transforms/OptRemarkGenerator.cpp b/lib/SILOptimizer/Transforms/OptRemarkGenerator.cpp
@@ -30,10 +30,17 @@
 #include "swift/SILOptimizer/Analysis/RCIdentityAnalysis.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace swift;
 
+static llvm::cl::opt<bool> ForceVisitImplicitAutogeneratedFunctions(
+    "optremarkgen-visit-implicit-autogen-funcs", llvm::cl::Hidden,
+    llvm::cl::desc(
+        "Emit opt remarks even on implicit and autogenerated functions"),
+    llvm::cl::init(false));
+
 //===----------------------------------------------------------------------===//
 //                                  Utility
 //===----------------------------------------------------------------------===//
@@ -347,6 +354,21 @@ class OptRemarkGenerator : public SILFunctionTransform {
       return;
 
     auto *fn = getFunction();
+
+    // Skip top level implicit functions and top level autogenerated functions,
+    // unless we were asked by the user to emit them.
+    if (!ForceVisitImplicitAutogeneratedFunctions) {
+      // Skip implicit functions generated by Sema.
+      if (auto *ctx = fn->getDeclContext())
+        if (auto *decl = ctx->getAsDecl())
+          if (decl->isImplicit())
+            return;
+      // Skip autogenerated functions generated by SILGen.
+      if (auto loc = fn->getDebugScope()->getLoc())
+        if (loc.isAutoGenerated())
+          return;
+    }
+
     LLVM_DEBUG(llvm::dbgs() << "Visiting: " << fn->getName() << "\n");
     auto &rcfi = *getAnalysis<RCIdentityAnalysis>()->get(fn);
     OptRemarkGeneratorInstructionVisitor visitor(*fn, rcfi);
diff --git a/lib/Serialization/ModuleDependencyScanner.cpp b/lib/Serialization/ModuleDependencyScanner.cpp
@@ -81,6 +81,12 @@ class ModuleDependencyScanner : public SerializedModuleLoaderBase {
       }
     }
     assert(fs.exists(InPath));
+    // Use the private interface file if exits.
+    auto PrivateInPath =
+      BaseName.getName(file_types::TY_PrivateSwiftModuleInterfaceFile);
+    if (fs.exists(PrivateInPath)) {
+      InPath = PrivateInPath;
+    }
     auto dependencies = scanInterfaceFile(InPath, IsFramework);
     if (dependencies) {
       this->dependencies = std::move(dependencies.get());
@@ -182,9 +188,8 @@ ErrorOr<ModuleDependencies> ModuleDependencyScanner::scanInterfaceFile(
   llvm::SmallString<32> modulePath = moduleName.str();
   llvm::sys::path::replace_extension(modulePath, newExt);
   Optional<ModuleDependencies> Result;
-  std::error_code code;
-
-  auto hasError = astDelegate.runInSubContext(moduleName.str(),
+  std::error_code code =
+    astDelegate.runInSubContext(moduleName.str(),
                                               moduleInterfacePath.str(),
                                               StringRef(),
                                               SourceLoc(),
@@ -205,8 +210,7 @@ ErrorOr<ModuleDependencies> ModuleDependencyScanner::scanInterfaceFile(
     auto &fs = *Ctx.SourceMgr.getFileSystem();
     auto interfaceBuf = fs.getBufferForFile(moduleInterfacePath);
     if (!interfaceBuf) {
-      code = interfaceBuf.getError();
-      return true;
+      return interfaceBuf.getError();
     }
 
     // Create a source file.
@@ -225,10 +229,10 @@ ErrorOr<ModuleDependencies> ModuleDependencyScanner::scanInterfaceFile(
     for (auto name: imInfo.ModuleNames) {
       Result->addModuleDependency(name.str(), &alreadyAddedModules);
     }
-    return false;
+    return std::error_code();
   });
 
-  if (hasError) {
+  if (code) {
     return code;
   }
   return *Result;
diff --git a/test/SILOptimizer/opt-remark-generator-force-emit-implicit-autogen.swift b/test/SILOptimizer/opt-remark-generator-force-emit-implicit-autogen.swift
@@ -0,0 +1,15 @@
+// RUN: %target-swiftc_driver -O -Rpass-missed=sil-opt-remark-gen -Xllvm -sil-disable-pass=FunctionSignatureOpts -emit-sil %s -o /dev/null -Xfrontend -verify -Xllvm -optremarkgen-visit-implicit-autogen-funcs=1
+
+class Klass {}
+
+struct KlassPair {
+    var lhs: Klass // expected-remark {{retain of type 'Klass'}}
+                   // expected-note @-1 {{of 'self.lhs'}}
+                   // expected-remark @-2 {{release of type 'Klass'}}
+                   // expected-note @-3 {{of 'self.lhs'}}
+    var rhs: Klass // expected-remark {{retain of type 'Klass'}}
+                   // expected-note @-1 {{of 'self.rhs'}}
+                   // expected-remark @-2 {{release of type 'Klass'}}
+                   // expected-note @-3 {{of 'self.rhs'}}
+}
+
diff --git a/test/SILOptimizer/opt-remark-generator.swift b/test/SILOptimizer/opt-remark-generator.swift
@@ -31,13 +31,7 @@ case third
 }
 
 struct StructWithOwner {
-    // This retain is from the initializers of owner.
-    //
-    // TODO: Should we emit this?
-    var owner = Klass() // expected-remark {{retain of type 'Klass'}}
-                        // expected-note @-1 {{of 'self.owner'}}
-                        // expected-remark @-2 {{release of type 'Klass'}}
-                        // expected-note @-3 {{of 'self.owner'}}
+    var owner = Klass()
     var state = TrivialState.first
 }
 
@@ -66,14 +60,8 @@ func callingAnInitializerStructWithOwner(x: Klass) -> StructWithOwner {
 }
 
 struct KlassPair {
-    var lhs: Klass // expected-remark {{retain of type 'Klass'}}
-                   // expected-note @-1 {{of 'self.lhs'}}
-                   // expected-remark @-2 {{release of type 'Klass'}}
-                   // expected-note @-3 {{of 'self.lhs'}}
-    var rhs: Klass // expected-remark {{retain of type 'Klass'}}
-                   // expected-note @-1 {{of 'self.rhs'}}
-                   // expected-remark @-2 {{release of type 'Klass'}}
-                   // expected-note @-3 {{of 'self.rhs'}}
+    var lhs: Klass
+    var rhs: Klass
 }
 
 func printKlassPair(x : KlassPair) {
diff --git a/test/ScanDependencies/module_deps_private_interface.swift b/test/ScanDependencies/module_deps_private_interface.swift
@@ -0,0 +1,16 @@
+// RUN: %empty-directory(%t)
+// RUN: mkdir -p %t/clang-module-cache
+// RUN: echo "// swift-interface-format-version: 1.0" > %t/Foo.swiftinterface
+// RUN: echo "// swift-module-flags: -module-name Foo" >> %t/Foo.swiftinterface
+// RUN: echo "public func foo() {}" >> %t/Foo.swiftinterface
+
+// RUN: cp %t/Foo.swiftinterface %t/Foo.private.swiftinterface
+
+// RUN: %target-swift-frontend -scan-dependencies -module-cache-path %t/clang-module-cache %s -o %t/deps.json -I %t -disable-implicit-swift-modules -Xcc -Xclang -Xcc -fno-implicit-modules
+
+// Check the contents of the JSON output
+// RUN: %FileCheck %s < %t/deps.json
+
+import Foo
+
+// CHECK: "moduleInterfacePath": "{{.*}}Foo.private.swiftinterface",
