Merge pull request swiftlang#33594 from nathawes/fix-missing-include

[master-rebranch] Merge in master and fix missing include in Decl.cpp

Author: Nathan Hawes

include/swift/AST/ClangNode.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_CLANGNODE_H
 #define SWIFT_CLANGNODE_H
 
+#include "swift/Basic/Debug.h"
 #include "llvm/ADT/PointerUnion.h"
 
 namespace clang {
@@ -98,6 +99,8 @@ class ClangNode {
   clang::SourceLocation getLocation() const;
   clang::SourceRange getSourceRange() const;
 
+  SWIFT_DEBUG_DUMP;
+
   void *getOpaqueValue() const { return Ptr.getOpaqueValue(); }
   static inline ClangNode getFromOpaqueValue(void *VP) {
     ClangNode N;

include/swift/AST/Decl.h

@@ -283,7 +283,7 @@ class alignas(1 << DeclAlignInBits) Decl {
 protected:
   union { uint64_t OpaqueBits;
 
-  SWIFT_INLINE_BITFIELD_BASE(Decl, bitmax(NumDeclKindBits,8)+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD_BASE(Decl, bitmax(NumDeclKindBits,8)+1+1+1+1,
     Kind : bitmax(NumDeclKindBits,8),
 
     /// Whether this declaration is invalid.
@@ -385,7 +385,7 @@ class alignas(1 << DeclAlignInBits) Decl {
   SWIFT_INLINE_BITFIELD(SubscriptDecl, VarDecl, 2,
     StaticSpelling : 2
   );
-  SWIFT_INLINE_BITFIELD(AbstractFunctionDecl, ValueDecl, 3+8+1+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(AbstractFunctionDecl, ValueDecl, 3+8+1+1+1+1+1+1,
     /// \see AbstractFunctionDecl::BodyKind
     BodyKind : 3,
 
@@ -2996,11 +2996,29 @@ class TypeAliasDecl : public GenericTypeDecl {
   /// Retrieve a sugared interface type containing the structure of the interface
   /// type before any semantic validation has occured.
   Type getStructuralType() const;
-  
+
+  /// Whether the typealias forwards perfectly to its underlying type.
+  ///
+  /// If true, this typealias was created by ClangImporter to preserve source
+  /// compatibility with a previous language version's name for a type. Many
+  /// checks in Sema look through compatibility aliases even when they would
+  /// operate on other typealiases.
+  ///
+  /// \warning This has absolutely nothing to do with the Objective-C
+  /// \c compatibility_alias keyword.
   bool isCompatibilityAlias() const {
     return Bits.TypeAliasDecl.IsCompatibilityAlias;
   }
 
+  /// Sets whether the typealias forwards perfectly to its underlying type.
+  ///
+  /// Marks this typealias as having been created by ClangImporter to preserve
+  /// source compatibility with a previous language version's name for a type.
+  /// Many checks in Sema look through compatibility aliases even when they
+  /// would operate on other typealiases.
+  ///
+  /// \warning This has absolutely nothing to do with the Objective-C
+  /// \c compatibility_alias keyword.
   void markAsCompatibilityAlias(bool newValue = true) {
     Bits.TypeAliasDecl.IsCompatibilityAlias = newValue;
   }

include/swift/AST/DiagnosticsCommon.def

@@ -185,5 +185,8 @@ WARNING(cross_imported_by_both_modules, none,
 ERROR(scanner_find_cycle, none,
       "dependency scanner detected dependency cycle: '%0'", (StringRef))
 
+ERROR(scanner_arguments_invalid, none,
+      "dependencies scanner cannot be configured with arguments: '%0'", (StringRef))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

lib/AST/Decl.cpp

@@ -59,6 +59,7 @@
 #include "swift/Demangling/ManglingMacros.h"
 
 #include "clang/Basic/CharInfo.h"
+#include "clang/Basic/Module.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclObjC.h"
 
@@ -116,6 +117,17 @@ const clang::Module *ClangNode::getClangModule() const {
   return nullptr;
 }
 
+void ClangNode::dump() const {
+  if (auto D = getAsDecl())
+    D->dump();
+  else if (auto M = getAsMacro())
+    M->dump();
+  else if (auto M = getAsModule())
+    M->dump();
+  else
+    llvm::errs() << "ClangNode contains nullptr\n";
+}
+
 // Only allow allocation of Decls using the allocator in ASTContext.
 void *Decl::operator new(size_t Bytes, const ASTContext &C,
                          unsigned Alignment) {

lib/FrontendTool/FrontendTool.cpp

@@ -1752,7 +1752,8 @@ static void performEndOfPipelineActions(CompilerInstance &Instance) {
 /// \param Instance Will be reset after performIRGeneration when the verifier
 ///                 mode is NoVerify and there were no errors.
 /// \returns true on error
-static bool performCompile(CompilerInstance &Instance,
+static bool performCompile(CompilerInvocation &Invok,
+                           CompilerInstance &Instance,
                            ArrayRef<const char *> Args,
                            int &ReturnValue,
                            FrontendObserver *observer) {
@@ -1840,7 +1841,8 @@ static bool performCompile(CompilerInstance &Instance,
     if (batchScanInput.empty())
       return finishPipeline(scanDependencies(Instance));
     else
-      return finishPipeline(batchScanModuleDependencies(Instance,
+      return finishPipeline(batchScanModuleDependencies(Invok,
+                                                        Instance,
                                                         batchScanInput));
   }
 
@@ -2653,7 +2655,7 @@ int swift::performFrontend(ArrayRef<const char *> Args,
   }
 
   int ReturnValue = 0;
-  bool HadError = performCompile(*Instance, Args, ReturnValue, observer);
+  bool HadError = performCompile(Invocation, *Instance, Args, ReturnValue, observer);
 
   if (verifierEnabled) {
     DiagnosticEngine &diags = Instance->getDiags();

lib/FrontendTool/ScanDependencies.cpp

@@ -31,6 +31,7 @@
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/YAMLTraits.h"
@@ -626,7 +627,6 @@ static bool diagnoseCycle(CompilerInstance &instance,
 
 static bool scanModuleDependencies(CompilerInstance &instance,
                                    StringRef moduleName,
-                                   StringRef arguments,
                                    bool isClang,
                                    StringRef outputPath) {
   ASTContext &ctx = instance.getASTContext();
@@ -685,25 +685,58 @@ static bool scanModuleDependencies(CompilerInstance &instance,
 bool swift::scanClangDependencies(CompilerInstance &instance) {
   return scanModuleDependencies(instance,
                                 instance.getMainModule()->getNameStr(),
-                                StringRef(),
                                 /*isClang*/true,
                                 instance.getInvocation().getFrontendOptions()
                                   .InputsAndOutputs.getSingleOutputFilename());
 }
 
-bool swift::batchScanModuleDependencies(CompilerInstance &instance,
-                                      llvm::StringRef batchInputFile) {
+bool swift::batchScanModuleDependencies(CompilerInvocation &invok,
+                                        CompilerInstance &instance,
+                                        llvm::StringRef batchInputFile) {
   (void)instance.getMainModule();
   llvm::BumpPtrAllocator alloc;
   llvm::StringSaver saver(alloc);
   auto results = parseBatchScanInputFile(instance.getASTContext(),
                                          batchInputFile, saver);
   if (!results.hasValue())
     return true;
+  auto &diags = instance.getDiags();
+  ForwardingDiagnosticConsumer FDC(diags);
+  // Keep track of all compiler instances we have created.
+  llvm::StringMap<std::unique_ptr<CompilerInstance>> subInstanceMap;
   for (auto &entry: *results) {
-    if (scanModuleDependencies(instance, entry.moduleName, entry.arguments,
-                               !entry.isSwift, entry.outputPath))
+    CompilerInstance *pInstance = nullptr;
+    if (entry.arguments.empty()) {
+      // Use the compiler's instance if no arguments are specified.
+      pInstance = &instance;
+    } else if (subInstanceMap.count(entry.arguments)) {
+      // Use the previously created instance if we've seen the arguments before.
+      pInstance = subInstanceMap[entry.arguments].get();
+    } else {
+      // Create a new instance by the arguments and save it in the map.
+      pInstance = subInstanceMap.insert({entry.arguments,
+        std::make_unique<CompilerInstance>()}).first->getValue().get();
+      SmallVector<const char*, 4> args;
+      llvm::cl::TokenizeGNUCommandLine(entry.arguments, saver, args);
+      CompilerInvocation subInvok = invok;
+      pInstance->addDiagnosticConsumer(&FDC);
+      if (subInvok.parseArgs(args, diags)) {
+        instance.getDiags().diagnose(SourceLoc(), diag::scanner_arguments_invalid,
+                                     entry.arguments);
+        return true;
+      }
+      if (pInstance->setup(subInvok)) {
+        instance.getDiags().diagnose(SourceLoc(), diag::scanner_arguments_invalid,
+                                     entry.arguments);
+        return true;
+      }
+    }
+    assert(pInstance);
+    // Scan using the chosen compiler instance.
+    if (scanModuleDependencies(*pInstance, entry.moduleName, !entry.isSwift,
+                               entry.outputPath)) {
       return true;
+    }
   }
   return false;
 }

lib/FrontendTool/ScanDependencies.h

@@ -17,10 +17,13 @@
 
 namespace swift {
 
+class CompilerInvocation;
 class CompilerInstance;
 
 /// Batch scan the dependencies for modules specified in \c batchInputFile.
-bool batchScanModuleDependencies(CompilerInstance &instance, llvm::StringRef batchInputFile);
+bool batchScanModuleDependencies(CompilerInvocation &invok,
+                                 CompilerInstance &instance,
+                                 llvm::StringRef batchInputFile);
 
 /// Scans the dependencies of the main module of \c instance.
 bool scanDependencies(CompilerInstance &instance);

lib/PrintAsObjC/DeclAndTypePrinter.cpp

@@ -1573,25 +1573,36 @@ class DeclAndTypePrinter::Implementation
   }
 
   bool printImportedAlias(const TypeAliasDecl *alias,
+                          ArrayRef<Type> genericArgs,
                           Optional<OptionalTypeKind> optionalKind) {
     if (!alias->hasClangNode())
       return false;
 
     if (auto *clangTypeDecl =
           dyn_cast<clang::TypeDecl>(alias->getClangDecl())) {
+      assert(!alias->isGeneric()
+             && "generic typealias backed by clang typedecl?");
+
       maybePrintTagKeyword(alias);
       os << getNameForObjC(alias);
 
       if (isClangPointerType(clangTypeDecl))
         printNullability(optionalKind);
     } else if (auto *clangObjCClass
                = dyn_cast<clang::ObjCInterfaceDecl>(alias->getClangDecl())){
+      assert(!alias->isGeneric()
+             && "generic typealias backed by clang interface?");
+
       os << clangObjCClass->getName() << " *";
       printNullability(optionalKind);
     } else {
       auto *clangCompatAlias =
       cast<clang::ObjCCompatibleAliasDecl>(alias->getClangDecl());
-      os << clangCompatAlias->getName() << " *";
+
+      os << clangCompatAlias->getName();
+      if (!genericArgs.empty())
+        printGenericArgs(genericArgs);
+      os << " *";
       printNullability(optionalKind);
     }
 
@@ -1601,10 +1612,12 @@ class DeclAndTypePrinter::Implementation
   void visitTypeAliasType(TypeAliasType *aliasTy,
                                Optional<OptionalTypeKind> optionalKind) {
     const TypeAliasDecl *alias = aliasTy->getDecl();
+    auto genericArgs = aliasTy->getDirectGenericArgs();
+
     if (printIfKnownSimpleType(alias, optionalKind))
       return;
 
-    if (printImportedAlias(alias, optionalKind))
+    if (printImportedAlias(alias, genericArgs, optionalKind))
       return;
 
     visitPart(aliasTy->getSinglyDesugaredType(), optionalKind);
@@ -1738,8 +1751,12 @@ class DeclAndTypePrinter::Implementation
   }
 
   void printGenericArgs(BoundGenericType *BGT) {
+    printGenericArgs(BGT->getGenericArgs());
+  }
+
+  void printGenericArgs(ArrayRef<Type> genericArgs) {
     os << '<';
-    interleave(BGT->getGenericArgs(),
+    interleave(genericArgs,
                [this](Type t) { print(t, None); },
                [this] { os << ", "; });
     os << '>';

lib/PrintAsObjC/ModuleContentsWriter.cpp

@@ -58,7 +58,6 @@ class ReferencedTypeFinder : public TypeDeclFinder {
   Action visitTypeAliasType(TypeAliasType *aliasTy) override {
     if (aliasTy->getDecl()->hasClangNode() &&
         !aliasTy->getDecl()->isCompatibilityAlias()) {
-      assert(!aliasTy->getDecl()->isGeneric());
       Callback(*this, aliasTy->getDecl());
     } else {
       Type(aliasTy->getSinglyDesugaredType()).walk(*this);
@@ -320,8 +319,10 @@ class ModuleWriter {
         } else if (auto PD = dyn_cast<ProtocolDecl>(TD)) {
           forwardDeclare(PD);
         } else if (auto TAD = dyn_cast<TypeAliasDecl>(TD)) {
+          bool imported = false;
           if (TAD->hasClangNode())
-            (void)addImport(TD);
+            imported = addImport(TD);
+          assert((imported || !TAD->isGeneric()) && "referencing non-imported generic typealias?");
         } else if (addImport(TD)) {
           return;
         } else if (auto ED = dyn_cast<EnumDecl>(TD)) {

lib/SILGen/SILGenPattern.cpp

@@ -1038,20 +1038,35 @@ void PatternMatchEmission::emitDispatch(ClauseMatrix &clauses, ArgArray args,
         SGF.eraseBasicBlock(contBB);
         return;
       }
-      
+
       // Otherwise, if there is no fallthrough, then the next row is
-      // unreachable: emit a dead code diagnostic.
+      // unreachable: emit a dead code diagnostic if:
+      // 1) It's for a 'default' case (since Space Engine already handles
+      //    unreachable enum case patterns) or it's for a enum case which
+      //    has expression patterns since redundancy checking for such
+      //    patterns isn't sufficiently done by the Space Engine.
+      // 2) It's for a case statement in a do-catch.
       if (!clauses[firstRow].hasFallthroughTo()) {
         SourceLoc Loc;
         bool isDefault = false;
+        bool isParentDoCatch = false;
+        bool caseHasExprPattern = false;
         if (auto *S = clauses[firstRow].getClientData<Stmt>()) {
           Loc = S->getStartLoc();
-          if (auto *CS = dyn_cast<CaseStmt>(S))
+          if (auto *CS = dyn_cast<CaseStmt>(S)) {
+            caseHasExprPattern = llvm::any_of(
+                CS->getCaseLabelItems(), [&](const CaseLabelItem item) {
+                  return item.getPattern()->getKind() == PatternKind::Expr;
+                });
+            isParentDoCatch = CS->getParentKind() == CaseParentKind::DoCatch;
             isDefault = CS->isDefault();
+          }
         } else {
           Loc = clauses[firstRow].getCasePattern()->getStartLoc();
         }
-        SGF.SGM.diagnose(Loc, diag::unreachable_case, isDefault);
+        if (isParentDoCatch || isDefault || caseHasExprPattern) {
+          SGF.SGM.diagnose(Loc, diag::unreachable_case, isDefault);
+        }
       }
     }
   }