Resolving conflicts

Author: LucianoPAlmeida

CHANGELOG.md

@@ -26,6 +26,21 @@ CHANGELOG
 Swift 5.2
 ---------
 
+* [SR-2189][]:
+
+  The compiler now supports local functions whose default arguments capture
+  values from outer scopes.
+
+  ```swift
+  func outer(x: Int) -> (Int, Int) {
+    func inner(y: Int = x) -> Int {
+      return y
+    }
+
+    return (inner(), inner(y: 0))
+  }
+  ```
+
 * [SR-11429][]:
 
   The compiler will now correctly strip argument labels from function references
@@ -7803,6 +7818,7 @@ Swift 1.0
 [SR-1529]: <https://bugs.swift.org/browse/SR-1529>
 [SR-2131]: <https://bugs.swift.org/browse/SR-2131>
 [SR-2176]: <https://bugs.swift.org/browse/SR-2176>
+[SR-2189]: <https://bugs.swift.org/browse/SR-2189>
 [SR-2388]: <https://bugs.swift.org/browse/SR-2388>
 [SR-2394]: <https://bugs.swift.org/browse/SR-2394>
 [SR-2608]: <https://bugs.swift.org/browse/SR-2608>

cmake/modules/SwiftHandleGybSources.cmake

@@ -121,6 +121,7 @@ function(handle_gyb_sources dependency_out_var_name sources_var_name arch)
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/DeclNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/ExprNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/GenericNodes.py"
+      "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/NodeSerializationCodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/PatternNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/StmtNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/TypeNodes.py"

include/swift/AST/Decl.h

@@ -5834,10 +5834,6 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   }
 
 public:
-  /// Compute the interface type of this function declaration from the
-  /// parameter types.
-  void computeType(AnyFunctionType::ExtInfo Info = FunctionType::ExtInfo());
-
   /// Retrieve the source range of the function body.
   SourceRange getBodySourceRange() const;
 

include/swift/AST/DiagnosticsSIL.def

@@ -130,24 +130,33 @@ ERROR(capture_before_declaration_defer,none,
 NOTE(captured_value_declared_here,none,
      "captured value declared here", ())
 
+#define SELECT_ESCAPING_CLOSURE_KIND "escaping %select{local function|closure}0"
+
 // Invalid escaping capture diagnostics.
 ERROR(escaping_inout_capture,none,
-      "escaping closure captures 'inout' parameter %0", (Identifier))
+      SELECT_ESCAPING_CLOSURE_KIND
+      " captures 'inout' parameter %1",
+      (unsigned, Identifier))
 NOTE(inout_param_defined_here,none,
      "parameter %0 is declared 'inout'", (Identifier))
 ERROR(escaping_mutable_self_capture,none,
-      "escaping closure captures mutating 'self' parameter", ())
+      SELECT_ESCAPING_CLOSURE_KIND
+      " captures mutating 'self' parameter", (unsigned))
 
 ERROR(escaping_noescape_param_capture,none,
-      "escaping closure captures non-escaping parameter %0", (Identifier))
+      SELECT_ESCAPING_CLOSURE_KIND
+      " captures non-escaping parameter %1", (unsigned, Identifier))
 NOTE(noescape_param_defined_here,none,
      "parameter %0 is implicitly non-escaping", (Identifier))
 
 ERROR(escaping_noescape_var_capture,none,
-      "escaping closure captures non-escaping value", ())
+      SELECT_ESCAPING_CLOSURE_KIND
+      " captures non-escaping value", (unsigned))
 
 NOTE(value_captured_here,none,"captured here", ())
 
+#undef SELECT_ESCAPING_CLOSURE_KIND
+
 NOTE(value_captured_transitively,none,
      "captured indirectly by this call", ())
 

include/swift/AST/DiagnosticsSema.def

@@ -3401,6 +3401,11 @@ ERROR(unresolved_label_corrected,none,
       "use of unresolved label %0; did you mean %1?",
       (Identifier, Identifier))
 
+ERROR(foreach_sequence_does_not_conform_to_expected_protocol,none,
+      "for-in loop requires %0 to conform to %1"
+      "%select{|; did you mean to unwrap optional?}2",
+      (Type, Type, bool))
+
 // Switch Stmt
 ERROR(no_match_operator,none,
       "no binary '~=' operator available for 'switch' statement", ())

include/swift/AST/IndexSubset.h

@@ -57,6 +57,10 @@ class IndexSubset : public llvm::FoldingSetNode {
   /// The number of bit words in the index subset.
   unsigned numBitWords;
 
+  static unsigned getNumBytesNeededForCapacity(unsigned capacity) {
+    return getNumBitWordsNeededForCapacity(capacity) * bitWordSize;
+  }
+
   BitWord *getBitWordsData() {
     return reinterpret_cast<BitWord *>(this + 1);
   }

include/swift/Frontend/Frontend.h

@@ -60,6 +60,18 @@ namespace Lowering {
 class TypeConverter;
 }
 
+struct ModuleBuffers {
+  std::unique_ptr<llvm::MemoryBuffer> ModuleBuffer;
+  std::unique_ptr<llvm::MemoryBuffer> ModuleDocBuffer;
+  std::unique_ptr<llvm::MemoryBuffer> ModuleSourceInfoBuffer;
+  ModuleBuffers(std::unique_ptr<llvm::MemoryBuffer> ModuleBuffer,
+                std::unique_ptr<llvm::MemoryBuffer> ModuleDocBuffer = nullptr,
+                std::unique_ptr<llvm::MemoryBuffer> ModuleSourceInfoBuffer = nullptr):
+                  ModuleBuffer(std::move(ModuleBuffer)),
+                  ModuleDocBuffer(std::move(ModuleDocBuffer)),
+                  ModuleSourceInfoBuffer(std::move(ModuleSourceInfoBuffer)) {}
+};
+
 /// The abstract configuration of the compiler, including:
 ///   - options for all stages of translation,
 ///   - information about the build environment,
@@ -392,15 +404,9 @@ class CompilerInstance {
   /// Contains buffer IDs for input source code files.
   std::vector<unsigned> InputSourceCodeBufferIDs;
 
-  struct PartialModuleInputs {
-    std::unique_ptr<llvm::MemoryBuffer> ModuleBuffer;
-    std::unique_ptr<llvm::MemoryBuffer> ModuleDocBuffer;
-    std::unique_ptr<llvm::MemoryBuffer> ModuleSourceInfoBuffer;
-  };
-
   /// Contains \c MemoryBuffers for partial serialized module files and
   /// corresponding partial serialized module documentation files.
-  std::vector<PartialModuleInputs> PartialModules;
+  std::vector<ModuleBuffers> PartialModules;
 
   enum : unsigned { NO_SUCH_BUFFER = ~0U };
   unsigned MainBufferID = NO_SUCH_BUFFER;
@@ -556,18 +562,6 @@ class CompilerInstance {
 
   Optional<unsigned> getRecordedBufferID(const InputFile &input, bool &failed);
 
-  struct ModuleBuffers {
-    std::unique_ptr<llvm::MemoryBuffer> ModuleBuffer;
-    std::unique_ptr<llvm::MemoryBuffer> ModuleDocBuffer;
-    std::unique_ptr<llvm::MemoryBuffer> ModuleSourceInfoBuffer;
-    ModuleBuffers(std::unique_ptr<llvm::MemoryBuffer> ModuleBuffer,
-                  std::unique_ptr<llvm::MemoryBuffer> ModuleDocBuffer = nullptr,
-                  std::unique_ptr<llvm::MemoryBuffer> ModuleSourceInfoBuffer = nullptr):
-                    ModuleBuffer(std::move(ModuleBuffer)),
-                    ModuleDocBuffer(std::move(ModuleDocBuffer)),
-                    ModuleSourceInfoBuffer(std::move(ModuleSourceInfoBuffer)) {}
-  };
-
   /// Given an input file, return a buffer to use for its contents,
   /// and a buffer for the corresponding module doc file if one exists.
   /// On failure, return a null pointer for the first element of the returned

include/swift/Parse/ParsedRawSyntaxNode.h

@@ -52,6 +52,7 @@ class ParsedRawSyntaxNode {
   };
   struct DeferredLayoutNode {
     MutableArrayRef<ParsedRawSyntaxNode> Children;
+    CharSourceRange Range;
   };
   struct DeferredTokenNode {
     const ParsedTriviaPiece *TriviaPieces;
@@ -72,9 +73,9 @@ class ParsedRawSyntaxNode {
   /// Primary used for capturing a deferred missing token.
   bool IsMissing = false;
 
-  ParsedRawSyntaxNode(syntax::SyntaxKind k,
+  ParsedRawSyntaxNode(syntax::SyntaxKind k, CharSourceRange r,
                       MutableArrayRef<ParsedRawSyntaxNode> deferredNodes)
-    : DeferredLayout({deferredNodes}),
+    : DeferredLayout({deferredNodes, r}),
       SynKind(uint16_t(k)), TokKind(uint16_t(tok::unknown)),
       DK(DataKind::DeferredLayout) {
     assert(getKind() == k && "Syntax kind with too large value!");
@@ -109,10 +110,12 @@ class ParsedRawSyntaxNode {
   }
 
   ParsedRawSyntaxNode(syntax::SyntaxKind k, tok tokKind,
-                      CharSourceRange r, OpaqueSyntaxNode n)
+                      CharSourceRange r, OpaqueSyntaxNode n,
+                      bool IsMissing = false)
     : RecordedData{n, r},
       SynKind(uint16_t(k)), TokKind(uint16_t(tokKind)),
-      DK(DataKind::Recorded) {
+      DK(DataKind::Recorded),
+      IsMissing(IsMissing) {
     assert(getKind() == k && "Syntax kind with too large value!");
     assert(getTokenKind() == tokKind && "Token kind with too large value!");
   }
@@ -209,9 +212,20 @@ class ParsedRawSyntaxNode {
     return copy;
   }
 
+  CharSourceRange getDeferredRange() const {
+    switch (DK) {
+    case DataKind::DeferredLayout:
+      return getDeferredLayoutRange();
+    case DataKind::DeferredToken:
+      return getDeferredTokenRangeWithTrivia();
+    default:
+      llvm_unreachable("node not deferred");
+    }
+  }
+
   // Recorded Data ===========================================================//
 
-  CharSourceRange getRange() const {
+  CharSourceRange getRecordedRange() const {
     assert(isRecorded());
     return RecordedData.Range;
   }
@@ -228,6 +242,10 @@ class ParsedRawSyntaxNode {
 
   // Deferred Layout Data ====================================================//
 
+  CharSourceRange getDeferredLayoutRange() const {
+    assert(DK == DataKind::DeferredLayout);
+    return DeferredLayout.Range;
+  }
   ArrayRef<ParsedRawSyntaxNode> getDeferredChildren() const {
     assert(DK == DataKind::DeferredLayout);
     return DeferredLayout.Children;
@@ -259,6 +277,19 @@ class ParsedRawSyntaxNode {
 
   // Deferred Token Data =====================================================//
 
+  CharSourceRange getDeferredTokenRangeWithTrivia() const {
+    assert(DK == DataKind::DeferredToken);
+    auto leadTriviaPieces = getDeferredLeadingTriviaPieces();
+    auto trailTriviaPieces = getDeferredTrailingTriviaPieces();
+
+    auto leadTriviaLen = ParsedTriviaPiece::getTotalLength(leadTriviaPieces);
+    auto trailTriviaLen = ParsedTriviaPiece::getTotalLength(trailTriviaPieces);
+
+    SourceLoc begin = DeferredToken.TokLoc.getAdvancedLoc(-leadTriviaLen);
+    unsigned len = leadTriviaLen + DeferredToken.TokLength + trailTriviaLen;
+
+    return CharSourceRange{begin, len};
+  }
   CharSourceRange getDeferredTokenRange() const {
     assert(DK == DataKind::DeferredToken);
     return CharSourceRange{DeferredToken.TokLoc, DeferredToken.TokLength};

include/swift/Parse/ParsedRawSyntaxRecorder.h

@@ -73,6 +73,10 @@ class ParsedRawSyntaxRecorder {
   /// Used for incremental re-parsing.
   ParsedRawSyntaxNode lookupNode(size_t lexerOffset, SourceLoc loc,
                                  syntax::SyntaxKind kind);
+
+  #ifndef NDEBUG
+  static void verifyElementRanges(ArrayRef<ParsedRawSyntaxNode> elements);
+  #endif
 };
 
 } // end namespace swift

include/swift/Parse/ParsedSyntaxBuilders.h.gyb

@@ -62,9 +62,9 @@ public:
 %     end
 
   Parsed${node.name} build();
-  Parsed${node.name} makeDeferred();
 
 private:
+  Parsed${node.name} makeDeferred();
   Parsed${node.name} record();
   void finishLayout(bool deferred);
 };

include/swift/Parse/ParsedSyntaxRecorder.h.gyb

@@ -43,23 +43,22 @@ struct ParsedSyntaxRecorder {
 %     end
 %     child_params = ', '.join(child_params)
 private:
-  static Parsed${node.name} record${node.syntax_kind}(${child_params},
+  static Parsed${node.name} record${node.syntax_kind}(MutableArrayRef<ParsedRawSyntaxNode> layout,
                                               ParsedRawSyntaxRecorder &rec);
-public:
-  static Parsed${node.name} defer${node.syntax_kind}(${child_params},
+  static Parsed${node.name} defer${node.syntax_kind}(MutableArrayRef<ParsedRawSyntaxNode> layout,
                                               SyntaxParsingContext &SPCtx);
+public:
   static Parsed${node.name} make${node.syntax_kind}(${child_params},
                                               SyntaxParsingContext &SPCtx);
 %   elif node.is_syntax_collection():
 private:
   static Parsed${node.name} record${node.syntax_kind}(
-      MutableArrayRef<Parsed${node.collection_element_type}> elts,
+      MutableArrayRef<ParsedRawSyntaxNode> layout,
       ParsedRawSyntaxRecorder &rec);
-
-public:
   static Parsed${node.name} defer${node.syntax_kind}(
-      MutableArrayRef<Parsed${node.collection_element_type}> elts,
+      MutableArrayRef<ParsedRawSyntaxNode> layout,
       SyntaxParsingContext &SPCtx);
+public:
   static Parsed${node.name} make${node.syntax_kind}(
       MutableArrayRef<Parsed${node.collection_element_type}> elts,
       SyntaxParsingContext &SPCtx);

include/swift/Parse/Parser.h

@@ -532,6 +532,10 @@ class Parser {
     return consumeToken();
   }
 
+  SourceLoc leadingTriviaLoc() {
+    return Tok.getLoc().getAdvancedLoc(-LeadingTrivia.getLength());
+  }
+
   SourceLoc consumeIdentifier(Identifier *Result = nullptr,
                               bool allowDollarIdentifier = false) {
     assert(Tok.isAny(tok::identifier, tok::kw_self, tok::kw_Self));

include/swift/Remote/MetadataReader.h

@@ -2613,6 +2613,13 @@ class MetadataReader {
     if (!Reader->readInteger(RemoteAddress(dataPtr + OffsetToROPtr), &dataPtr))
       return StoredPointer();
 
+    // Newer Objective-C runtimes implement a size optimization where the RO
+    // field is a tagged union. If the low-bit is set, then the pointer needs
+    // to be dereferenced once more to yield the real class_ro_t pointer.
+    if (dataPtr & 1)
+      if (!Reader->readInteger(RemoteAddress(dataPtr^1), &dataPtr))
+        return StoredPointer();
+
     return dataPtr;
   }
 

include/swift/SILOptimizer/Analysis/BasicCalleeAnalysis.h

@@ -54,6 +54,11 @@ class CalleeList {
       : CalleeFunctions(llvm::makeArrayRef(List.begin(), List.end())),
         IsIncomplete(IsIncomplete) {}
 
+  LLVM_ATTRIBUTE_DEPRECATED(void dump() const LLVM_ATTRIBUTE_USED,
+                            "Only for use in the debugger");
+
+  void print(llvm::raw_ostream &os) const;
+
   /// Return an iterator for the beginning of the list.
   ArrayRef<SILFunction *>::iterator begin() const {
     return CalleeFunctions.begin();
@@ -67,7 +72,7 @@ class CalleeList {
   bool isIncomplete() const { return IsIncomplete; }
 
   /// Returns true if all callees are known and not external.
-  bool allCalleesVisible();
+  bool allCalleesVisible() const;
 };
 
 /// CalleeCache is a helper class that builds lists of potential
@@ -106,16 +111,16 @@ class CalleeCache {
   /// given instruction. E.g. it could be destructors.
   CalleeList getCalleeList(SILInstruction *I) const;
 
+  CalleeList getCalleeList(SILDeclRef Decl) const;
+
 private:
   void enumerateFunctionsInModule();
   void sortAndUniqueCallees();
   CalleesAndCanCallUnknown &getOrCreateCalleesForMethod(SILDeclRef Decl);
-  void computeClassMethodCalleesForClass(ClassDecl *CD);
-  void computeClassMethodCallees(ClassDecl *CD, SILDeclRef Method);
+  void computeClassMethodCallees();
   void computeWitnessMethodCalleesForWitnessTable(SILWitnessTable &WT);
   void computeMethodCallees();
   SILFunction *getSingleCalleeForWitnessMethod(WitnessMethodInst *WMI) const;
-  CalleeList getCalleeList(SILDeclRef Decl) const;
   CalleeList getCalleeList(WitnessMethodInst *WMI) const;
   CalleeList getCalleeList(ClassMethodInst *CMI) const;
   CalleeList getCalleeListForCalleeKind(SILValue Callee) const;
@@ -162,17 +167,23 @@ class BasicCalleeAnalysis : public SILAnalysis {
     Cache.reset();
   }
 
-  CalleeList getCalleeList(FullApplySite FAS) {
+  LLVM_ATTRIBUTE_DEPRECATED(void dump() const LLVM_ATTRIBUTE_USED,
+                            "Only for use in the debugger");
+
+  void print(llvm::raw_ostream &os) const;
+
+  void updateCache() {
     if (!Cache)
       Cache = llvm::make_unique<CalleeCache>(M);
+  }
 
+  CalleeList getCalleeList(FullApplySite FAS) {
+    updateCache();
     return Cache->getCalleeList(FAS);
   }
 
   CalleeList getCalleeList(SILInstruction *I) {
-    if (!Cache)
-      Cache = llvm::make_unique<CalleeCache>(M);
-
+    updateCache();
     return Cache->getCalleeList(I);
   }
 };