Merge pull request #5255 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

docs/ABI/Mangling.rst

@@ -348,7 +348,7 @@ Entities
   entity-spec ::= type 'fU' INDEX            // explicit anonymous closure expression
   entity-spec ::= type 'fu' INDEX            // implicit anonymous closure
   entity-spec ::= 'fA' INDEX                 // default argument N+1 generator
-  entity-spec ::= 'fa'                       // runtime discoverable attribute generator
+  entity-spec ::= entity 'fa'                // runtime discoverable attribute generator
   entity-spec ::= 'fi'                       // non-local variable initializer
   entity-spec ::= 'fP'                       // property wrapper backing initializer
   entity-spec ::= 'fW'                       // property wrapper init from projected value
@@ -396,7 +396,10 @@ Entities
 
   macro-discriminator-list ::= macro-discriminator-list? 'fM' macro-expansion-operator INDEX
 
+  macro-expansion-operator ::= identifier 'a' // accessor attached macro
+  macro-expansion-operator ::= identifier 'A' // member-attribute attached macro
   macro-expansion-operator ::= identifier 'f' // freestanding macro
+  macro-expansion-operator ::= identifier 'm' // member attached macro
   macro-expansion-operator ::= identifier 'u' // uniquely-named entity
 
   file-discriminator ::= identifier 'Ll'     // anonymous file-discriminated declaration

include/swift/AST/ASTMangler.h

@@ -343,6 +343,7 @@ class ASTMangler : public Mangler {
 
   std::string mangleTypeAsContextUSR(const NominalTypeDecl *type);
 
+  void appendAnyDecl(const ValueDecl *Decl);
   std::string mangleAnyDecl(const ValueDecl *Decl, bool prefix,
                             bool respectOriginallyDefinedIn = false);
   std::string mangleDeclAsUSR(const ValueDecl *Decl, StringRef USRPrefix);
@@ -368,9 +369,12 @@ class ASTMangler : public Mangler {
 
   std::string mangleMacroExpansion(const MacroExpansionExpr *expansion);
   std::string mangleMacroExpansion(const MacroExpansionDecl *expansion);
+  std::string mangleAttachedMacroExpansion(
+      const Decl *decl, CustomAttr *attr, MacroRole role);
+
   void appendMacroExpansionContext(SourceLoc loc, DeclContext *origDC);
   void appendMacroExpansionOperator(
-      StringRef macroName, unsigned discriminator);
+      StringRef macroName, MacroRole role, unsigned discriminator);
 
   enum SpecialContext {
     ObjCContext,

include/swift/AST/ASTScope.h

@@ -955,6 +955,7 @@ class PatternEntryInitializerScope final : public AbstractPatternEntryScope {
 
 protected:
   bool lookupLocalsOrMembers(DeclConsumer) const override;
+  bool isLabeledStmtLookupTerminator() const override;
 };
 
 /// The scope introduced by a conditional clause initializer in an

include/swift/AST/ASTTypeIDZone.def

@@ -26,6 +26,7 @@ SWIFT_TYPEID(Fingerprint)
 SWIFT_TYPEID(GenericSignature)
 SWIFT_TYPEID(ImplicitImportList)
 SWIFT_TYPEID(ImplicitMemberAction)
+SWIFT_TYPEID(IsSingleValueStmtResult)
 SWIFT_TYPEID(ParamSpecifier)
 SWIFT_TYPEID(PropertyWrapperAuxiliaryVariables)
 SWIFT_TYPEID(PropertyWrapperInitializerInfo)

include/swift/AST/ASTTypeIDs.h

@@ -41,6 +41,7 @@ class GenericParamList;
 class GenericSignature;
 class GenericTypeParamType;
 class InfixOperatorDecl;
+class IsSingleValueStmtResult;
 class IterableDeclContext;
 class ModuleDecl;
 struct ImplicitImportList;

include/swift/AST/AccessScope.h

@@ -85,13 +85,13 @@ class AccessScope {
     return !Value.getPointer() && Value.getInt() == AccessLimitKind::Package;
   }
 
-  /// Returns true if this scope is more restrictive than the argument scope.
-  /// It's often used to compute the min access scope. The order of restrictiveness
-  /// is: private (most restrictive), fileprivate, internal, package, public (least restrictive).
-  /// \see DeclContext::isChildContextOf
+  /// Returns true if the context of this (use site) is more restrictive than
+  /// the argument context (decl site). This function does _not_ check the
+  /// restrictiveness of the access level between this and the argument. \see
+  /// AccessScope::isInContext
   bool isChildOf(AccessScope AS) const {
-    if (isInternalOrLess()) {
-      if (AS.isInternalOrLess())
+    if (isInContext()) {
+      if (AS.isInContext())
         return allowsPrivateAccess(getDeclContext(), AS.getDeclContext());
       else
         return AS.isPackage() || AS.isPublic();
@@ -103,7 +103,27 @@ class AccessScope {
     return false;
   }
 
-  bool isInternalOrLess() const { return getDeclContext() != nullptr; }
+  /// Result depends on whether it's called at a use site or a decl site:
+  ///
+  /// For example,
+  ///
+  /// ```
+  /// public func foo(_ arg: bar) {} // `bar` is a `package` decl in another
+  /// module
+  /// ```
+  ///
+  /// The meaning of \c isInContext changes whether it's at the use site or the
+  /// decl site.
+  ///
+  /// The use site of \c bar, i.e. \c foo, is "in context" (decl context is
+  /// non-null), regardless of the access level of \c foo (\c public in this
+  /// case).
+  ///
+  /// The decl site of \c bar is only "in context" if the access level of the
+  /// decl is \c internal or more restrictive. The context at the decl site is\c
+  /// FileUnit if the decl is \c fileprivate or \c private; \c ModuleDecl if \c
+  /// internal, and null if \c package or \c public.
+  bool isInContext() const { return getDeclContext() != nullptr; }
 
   /// Returns the associated access level for diagnostic purposes.
   AccessLevel accessLevelForDiagnostics() const;

include/swift/AST/CASTBridging.h

@@ -169,6 +169,9 @@ void *SwiftVarDecl_create(void *ctx, BridgedIdentifier _Nullable name,
                           void *initExpr, void *loc, _Bool isStatic,
                           _Bool isLet, void *dc);
 
+void *SingleValueStmtExpr_createWithWrappedBranches(void *ctx, void *S,
+                                                    void *DC, _Bool mustBeExpr);
+
 void *IfStmt_create(void *ctx, void *ifLoc, void *cond, void *_Nullable then,
                     void *_Nullable elseLoc, void *_Nullable elseStmt);
 

include/swift/AST/Decl.h

@@ -875,6 +875,11 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   /// declaration.
   void forEachAttachedMacro(MacroRole role, MacroCallback) const;
 
+  /// Retrieve the discriminator for the given custom attribute that names
+  /// an attached macro.
+  unsigned getAttachedMacroDiscriminator(
+      MacroRole role, const CustomAttr *attr) const;
+
   /// Returns the innermost enclosing decl with an availability annotation.
   const Decl *getInnermostDeclWithAvailability() const;
 

include/swift/AST/DiagnosticsSema.def

@@ -1108,6 +1108,29 @@ ERROR(ternary_expr_cases_mismatch,none,
       "result values in '? :' expression have mismatching types %0 and %1",
       (Type, Type))
 
+// Statements as expressions
+ERROR(single_value_stmt_branches_mismatch,none,
+      "branches have mismatching types %0 and %1",
+      (Type, Type))
+ERROR(single_value_stmt_out_of_place,none,
+      "'%0' may only be used as expression in return, throw, or as the source "
+      "of an assignment",
+      (StmtKind))
+ERROR(single_value_stmt_must_be_unlabeled,none,
+      "'%0' cannot have a jump label when used as expression",
+      (StmtKind))
+ERROR(if_expr_must_be_syntactically_exhaustive,none,
+      "'if' must have an unconditional 'else' to be used as expression",
+      ())
+ERROR(single_value_stmt_branch_must_end_in_throw,none,
+      "non-expression branch of '%0' expression may only end with a 'throw'",
+      (StmtKind))
+ERROR(cannot_jump_in_single_value_stmt,none,
+      "cannot '%0' in '%1' when used as expression",
+      (StmtKind, StmtKind))
+ERROR(effect_marker_on_single_value_stmt,none,
+      "'%0' may not be used on '%1' expression", (StringRef, StmtKind))
+
 ERROR(did_not_call_function_value,none,
       "function value was used as a property; add () to call it",
       ())

include/swift/AST/Expr.h

@@ -4360,6 +4360,10 @@ class OpaqueValueExpr : public Expr {
     Bits.OpaqueValueExpr.IsPlaceholder = isPlaceholder;
   }
 
+  static OpaqueValueExpr *
+  createImplicit(ASTContext &ctx, Type Ty, bool isPlaceholder = false,
+                 AllocationArena arena = AllocationArena::Permanent);
+
   /// Whether this opaque value expression represents a placeholder that
   /// is injected before type checking to act as a placeholder for some
   /// value to be specified later.
@@ -5975,6 +5979,63 @@ class KeyPathDotExpr : public Expr {
   }
 };
 
+/// An expression that may wrap a statement which produces a single value.
+class SingleValueStmtExpr : public Expr {
+public:
+  enum class Kind {
+    If, Switch
+  };
+
+private:
+  Stmt *S;
+  DeclContext *DC;
+
+  SingleValueStmtExpr(Stmt *S, DeclContext *DC)
+      : Expr(ExprKind::SingleValueStmt, /*isImplicit*/ true), S(S), DC(DC) {}
+
+public:
+  /// Creates a new SingleValueStmtExpr wrapping a statement.
+  static SingleValueStmtExpr *create(ASTContext &ctx, Stmt *S, DeclContext *DC);
+
+  /// Creates a new SingleValueStmtExpr wrapping a statement, and recursively
+  /// attempts to wrap any branches of that statement that can become single
+  /// value statement expressions.
+  ///
+  /// If \p mustBeExpr is true, branches will be eagerly wrapped even if they
+  /// may not be valid SingleValueStmtExprs (which Sema will later diagnose).
+  static SingleValueStmtExpr *createWithWrappedBranches(ASTContext &ctx,
+                                                        Stmt *S,
+                                                        DeclContext *DC,
+                                                        bool mustBeExpr);
+
+  /// Attempt to look through valid parent expressions to a child
+  /// SingleValueStmtExpr.
+  static SingleValueStmtExpr *tryDigOutSingleValueStmtExpr(Expr *E);
+
+  /// Retrieve the wrapped statement.
+  Stmt *getStmt() const { return S; }
+  void setStmt(Stmt *newS) { S = newS; }
+
+  /// Retrieve the kind of statement being wrapped.
+  Kind getStmtKind() const;
+
+  /// Retrieve the complete set of branches for the underlying statement.
+  ArrayRef<Stmt *> getBranches(SmallVectorImpl<Stmt *> &scratch) const;
+
+  /// Retrieve the single expression branches of the statement, excluding
+  /// branches that either have multiple expressions, or have statements.
+  ArrayRef<Expr *>
+  getSingleExprBranches(SmallVectorImpl<Expr *> &scratch) const;
+
+  DeclContext *getDeclContext() const { return DC; }
+
+  SourceRange getSourceRange() const;
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::SingleValueStmt;
+  }
+};
+
 /// Expression node that effects a "one-way" constraint in
 /// the constraint system, allowing type information to flow from the
 /// subexpression outward but not the other way.
@@ -6008,6 +6069,10 @@ class TypeJoinExpr final : public Expr,
 
   DeclRefExpr *Var;
 
+  /// If this is joining the expression branches for a SingleValueStmtExpr,
+  /// this holds the expr node. Otherwise, it is \c nullptr.
+  SingleValueStmtExpr *SVE;
+
   size_t numTrailingObjects() const {
     return getNumElements();
   }
@@ -6016,11 +6081,34 @@ class TypeJoinExpr final : public Expr,
     return { getTrailingObjects<Expr *>(), getNumElements() };
   }
 
-  TypeJoinExpr(DeclRefExpr *var, ArrayRef<Expr *> elements);
+  TypeJoinExpr(llvm::PointerUnion<DeclRefExpr *, TypeBase *> result,
+               ArrayRef<Expr *> elements, SingleValueStmtExpr *SVE);
+
+  static TypeJoinExpr *
+  createImpl(ASTContext &ctx,
+             llvm::PointerUnion<DeclRefExpr *, TypeBase *> varOrType,
+             ArrayRef<Expr *> elements,
+             AllocationArena arena = AllocationArena::Permanent,
+             SingleValueStmtExpr *SVE = nullptr);
 
 public:
-  static TypeJoinExpr *create(ASTContext &ctx, DeclRefExpr *var,
-                              ArrayRef<Expr *> exprs);
+  static TypeJoinExpr *
+  create(ASTContext &ctx, DeclRefExpr *var, ArrayRef<Expr *> exprs,
+         AllocationArena arena = AllocationArena::Permanent) {
+    return createImpl(ctx, var, exprs, arena);
+  }
+
+  static TypeJoinExpr *
+  create(ASTContext &ctx, Type joinType, ArrayRef<Expr *> exprs,
+         AllocationArena arena = AllocationArena::Permanent) {
+    return createImpl(ctx, joinType.getPointer(), exprs, arena);
+  }
+
+  /// Create a join for the branch types of a SingleValueStmtExpr.
+  static TypeJoinExpr *
+  forBranchesOfSingleValueStmtExpr(ASTContext &ctx, Type joinType,
+                                   SingleValueStmtExpr *SVE,
+                                   AllocationArena arena);
 
   SourceLoc getLoc() const { return SourceLoc(); }
   SourceRange getSourceRange() const { return SourceRange(); }
@@ -6044,6 +6132,10 @@ class TypeJoinExpr final : public Expr,
     getMutableElements()[i] = E;
   }
 
+  /// If this is joining the expression branches for a SingleValueStmtExpr,
+  /// this returns the expr node. Otherwise, returns \c nullptr.
+  SingleValueStmtExpr *getSingleValueStmtExpr() const { return SVE; }
+
   unsigned getNumElements() const { return Bits.TypeJoinExpr.NumElements; }
 
   static bool classof(const Expr *E) {