Merge branch 'main' of github.com:apple/swift into declaration-macro-name-lookup

Author: rxwei

docs/ABI/Mangling.rst

@@ -365,6 +365,7 @@ Entities
   entity-spec ::= decl-name type 'fp'                                               // generic type parameter
   entity-spec ::= decl-name type 'fo'                                               // enum element (currently not used)
   entity-spec ::= decl-name label-list? type generic-signature? 'fm'   // macro
+  entity-spec ::= context macro-discriminator-list  // macro expansion
   entity-spec ::= identifier 'Qa'                                                   // associated type declaration
 
   ACCESSOR ::= 'm'                           // materializeForSet
@@ -392,6 +393,10 @@ Entities
   RELATED-DISCRIMINATOR ::= [a-j]
   RELATED-DISCRIMINATOR ::= [A-J]
 
+  macro-discriminator-list ::= macro-discriminator-list? 'fM' macro-expansion-operator INDEX
+
+  macro-expansion-operator ::= 'f' // freestanding macro
+
   file-discriminator ::= identifier 'Ll'     // anonymous file-discriminated declaration
 
 The identifier in a ``<file-discriminator>`` and the second identifier in a

include/swift/AST/ASTContext.h

@@ -87,6 +87,7 @@ namespace swift {
   class LazyContextData;
   class LazyIterableDeclContextData;
   class LazyMemberLoader;
+  struct MacroDiscriminatorContext;
   class ModuleDependencyInfo;
   class PatternBindingDecl;
   class PatternBindingInitializer;
@@ -1070,6 +1071,11 @@ class ASTContext final {
       AbstractFunctionDecl *originalAFD, unsigned previousGeneration,
       llvm::SetVector<AutoDiffConfig> &results);
 
+  /// Retrieve the next macro expansion discriminator within the given
+  /// name and context.
+  unsigned getNextMacroDiscriminator(MacroDiscriminatorContext context,
+                                     DeclBaseName baseName);
+
   /// Retrieve the Clang module loader for this ASTContext.
   ///
   /// If there is no Clang module loader, returns a null pointer.

include/swift/AST/ASTMangler.h

@@ -26,6 +26,7 @@ namespace swift {
 
 class AbstractClosureExpr;
 class ConformancePath;
+class MacroExpansionExpr;
 class RootProtocolConformance;
 
 namespace Mangle {
@@ -365,6 +366,12 @@ class ASTMangler : public Mangler {
   mangleRuntimeAttributeGeneratorEntity(const ValueDecl *decl, CustomAttr *attr,
                                         SymbolKind SKind = SymbolKind::Default);
 
+  std::string mangleMacroExpansion(const MacroExpansionExpr *expansion);
+  std::string mangleMacroExpansion(const MacroExpansionDecl *expansion);
+  void appendMacroExpansionContext(SourceLoc loc, DeclContext *origDC);
+  void appendMacroExpansionOperator(
+      StringRef macroName, unsigned discriminator);
+
   enum SpecialContext {
     ObjCContext,
     ClangImporterContext,

include/swift/AST/Decl.h

@@ -726,6 +726,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     NumberOfVTableEntries : 2
   );
 
+  SWIFT_INLINE_BITFIELD(MacroExpansionDecl, Decl, 16,
+    Discriminator : 16
+  );
+
   } Bits;
 
   // Storage for the declaration attributes.
@@ -8456,6 +8460,8 @@ class MacroExpansionDecl : public Decl {
   ConcreteDeclRef macroRef;
 
 public:
+  enum : unsigned { InvalidDiscriminator = 0xFFFF };
+
   MacroExpansionDecl(DeclContext *dc, SourceLoc poundLoc, DeclNameRef macro,
                      DeclNameLoc macroLoc,
                      SourceLoc leftAngleLoc,
@@ -8465,7 +8471,9 @@ class MacroExpansionDecl : public Decl {
       : Decl(DeclKind::MacroExpansion, dc), PoundLoc(poundLoc),
         Macro(macro), MacroLoc(macroLoc),
         LeftAngleLoc(leftAngleLoc), RightAngleLoc(rightAngleLoc),
-        GenericArgs(genericArgs), ArgList(args) {}
+        GenericArgs(genericArgs), ArgList(args) {
+    Bits.MacroExpansionDecl.Discriminator = InvalidDiscriminator;
+  }
 
   ArrayRef<TypeRepr *> getGenericArgs() const { return GenericArgs; }
 
@@ -8486,6 +8494,24 @@ class MacroExpansionDecl : public Decl {
   void setMacroRef(ConcreteDeclRef ref) { macroRef = ref; }
   MacroExpansionExpr *createExpr() const;
 
+  /// Returns a discriminator which determines this macro expansion's index
+  /// in the sequence of macro expansions within the current function.
+  unsigned getDiscriminator() const;
+
+  /// Retrieve the raw discriminator, which may not have been computed yet.
+  ///
+  /// Only use this for queries that are checking for (e.g.) reentrancy or
+  /// intentionally do not want to initiate verification.
+  unsigned getRawDiscriminator() const {
+    return Bits.MacroExpansionDecl.Discriminator;
+  }
+
+  void setDiscriminator(unsigned discriminator) {
+    assert(getRawDiscriminator() == InvalidDiscriminator);
+    assert(discriminator != InvalidDiscriminator);
+    Bits.MacroExpansionDecl.Discriminator = discriminator;
+  }
+
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::MacroExpansion;
   }

include/swift/AST/DiagnosticsSIL.def

@@ -743,7 +743,13 @@ ERROR(sil_moveonlychecker_value_consumed_in_a_loop, none,
       "'%0' consumed by a use in a loop", (StringRef))
 ERROR(sil_moveonlychecker_exclusivity_violation, none,
       "'%0' has consuming use that cannot be eliminated due to a tight exclusivity scope", (StringRef))
+ERROR(sil_moveonlychecker_moveonly_field_consumed, none,
+      "'%0' has a move only field that was consumed before later uses", (StringRef))
 
+NOTE(sil_moveonlychecker_moveonly_field_consumed_here, none,
+     "move only field consumed here", ())
+NOTE(sil_moveonlychecker_boundary_use, none,
+     "boundary use here", ())
 NOTE(sil_moveonlychecker_consuming_use_here, none,
      "consuming use", ())
 NOTE(sil_moveonlychecker_consuming_closure_use_here, none,

include/swift/AST/Expr.h

@@ -363,6 +363,12 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
     : NumPadBits,
     NumElements : 32
   );
+
+  SWIFT_INLINE_BITFIELD(MacroExpansionExpr, Expr, (16-NumExprBits)+16,
+    : 16 - NumExprBits, // Align and leave room for subclasses
+    Discriminator : 16
+  );
+
   } Bits;
 
 private:
@@ -6047,6 +6053,7 @@ class TypeJoinExpr final : public Expr,
 
 class MacroExpansionExpr final : public Expr {
 private:
+  DeclContext *DC;
   SourceLoc PoundLoc;
   DeclNameRef MacroName;
   DeclNameLoc MacroNameLoc;
@@ -6059,19 +6066,26 @@ class MacroExpansionExpr final : public Expr {
   ConcreteDeclRef macroRef;
 
 public:
-  explicit MacroExpansionExpr(SourceLoc poundLoc, DeclNameRef macroName,
+  enum : unsigned { InvalidDiscriminator = 0xFFFF };
+
+  explicit MacroExpansionExpr(DeclContext *dc,
+                              SourceLoc poundLoc, DeclNameRef macroName,
                               DeclNameLoc macroNameLoc,
                               SourceLoc leftAngleLoc,
                               ArrayRef<TypeRepr *> genericArgs,
                               SourceLoc rightAngleLoc,
-                              ArgumentList *argList, bool isImplicit = false,
+                              ArgumentList *argList,
+                              bool isImplicit = false,
                               Type ty = Type())
-      : Expr(ExprKind::MacroExpansion, isImplicit, ty), PoundLoc(poundLoc),
+      : Expr(ExprKind::MacroExpansion, isImplicit, ty),
+        DC(dc), PoundLoc(poundLoc),
         MacroName(macroName), MacroNameLoc(macroNameLoc),
         LeftAngleLoc(leftAngleLoc), RightAngleLoc(rightAngleLoc),
         GenericArgs(genericArgs),
         ArgList(argList),
-        Rewritten(nullptr) { }
+        Rewritten(nullptr) {
+    Bits.MacroExpansionExpr.Discriminator = InvalidDiscriminator;
+  }
 
   DeclNameRef getMacroName() const { return MacroName; }
   DeclNameLoc getMacroNameLoc() const { return MacroNameLoc; }
@@ -6093,6 +6107,27 @@ class MacroExpansionExpr final : public Expr {
   ConcreteDeclRef getMacroRef() const { return macroRef; }
   void setMacroRef(ConcreteDeclRef ref) { macroRef = ref; }
 
+  DeclContext *getDeclContext() const { return DC; }
+  void setDeclContext(DeclContext *dc) { DC = dc; }
+
+  /// Returns a discriminator which determines this macro expansion's index
+  /// in the sequence of macro expansions within the current function.
+  unsigned getDiscriminator() const;
+
+  /// Retrieve the raw discriminator, which may not have been computed yet.
+  ///
+  /// Only use this for queries that are checking for (e.g.) reentrancy or
+  /// intentionally do not want to initiate verification.
+  unsigned getRawDiscriminator() const {
+    return Bits.MacroExpansionExpr.Discriminator;
+  }
+
+  void setDiscriminator(unsigned discriminator) {
+    assert(getRawDiscriminator() == InvalidDiscriminator);
+    assert(discriminator != InvalidDiscriminator);
+    Bits.MacroExpansionExpr.Discriminator = discriminator;
+  }
+
   SourceRange getSourceRange() const;
 
   static bool classof(const Expr *E) {

include/swift/AST/MacroDiscriminatorContext.h

@@ -0,0 +1,38 @@
+//===--- MacroDiscriminatorContext.h - Macro Discriminators -----*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_MACRO_DISCRIMINATOR_CONTEXT_H
+#define SWIFT_AST_MACRO_DISCRIMINATOR_CONTEXT_H
+
+#include "swift/AST/Decl.h"
+#include "swift/AST/Expr.h"
+#include "llvm/ADT/PointerUnion.h"
+
+namespace swift {
+
+/// Describes the context of a macro expansion for the purpose of
+/// computing macro expansion discriminators.
+struct MacroDiscriminatorContext
+    : public llvm::PointerUnion<DeclContext *, MacroExpansionExpr *,
+                                MacroExpansionDecl *> {
+  using PointerUnion::PointerUnion;
+
+  static MacroDiscriminatorContext getParentOf(MacroExpansionExpr *expansion);
+  static MacroDiscriminatorContext getParentOf(MacroExpansionDecl *expansion);
+  static MacroDiscriminatorContext getParentOf(
+      SourceLoc loc, DeclContext *origDC
+  );
+};
+
+}
+
+#endif // SWIFT_AST_MACRO_DISCRIMINATOR_CONTEXT_H

include/swift/Basic/FrozenMultiMap.h

@@ -122,7 +122,11 @@ class FrozenMultiMap {
 
   bool isFrozen() const { return frozen; }
 
-  /// Set this map into its frozen state when we
+  /// Set this map into its frozen state. This stable sorts our internal array
+  /// to create our map like context.
+  ///
+  /// After this, one can only use map like operations and non-mutable vector
+  /// operations instead of full mutable/non-mutable vector operations.
   void setFrozen() {
     std::stable_sort(storage.begin(), storage.end(),
                      [&](const std::pair<Key, Optional<Value>> &lhs,
@@ -134,6 +138,13 @@ class FrozenMultiMap {
     frozen = true;
   }
 
+  /// Unfreeze the map, so one can go back to using mutable vector
+  /// operations. After one calls this until one freezes the map again, one
+  /// cannot use map operations.
+  ///
+  /// This allows one to incrementally update the map.
+  void unfreeze() { frozen = false; }
+
   /// Reset the frozen multimap in an unfrozen state with its storage cleared.
   void reset() {
     storage.clear();

include/swift/Demangling/DemangleNodes.def

@@ -148,6 +148,7 @@ NODE(LazyProtocolWitnessTableAccessor)
 NODE(LazyProtocolWitnessTableCacheVariable)
 NODE(LocalDeclName)
 NODE(Macro)
+NODE(MacroExpansion)
 CONTEXT_NODE(MaterializeForSet)
 NODE(MergedFunction)
 NODE(Metatype)

include/swift/Demangling/Demangler.h

@@ -589,6 +589,7 @@ class Demangler : public NodeFactory {
   NodePointer demangleGenericRequirement();
   NodePointer demangleGenericType();
   NodePointer demangleValueWitness();
+  NodePointer demangleMacroExpansion();
 
   NodePointer demangleTypeMangling();
   NodePointer demangleSymbolicReference(unsigned char rawKind);