Merge pull request #4945 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

docs/CppInteroperability/CppInteroperabilityStatus.md

@@ -163,7 +163,7 @@ This status table describes which of the following Swift language features have
 | Copy and destroy semantics   | Yes                                                      |
 | Creation                     | Yes                                                      |
 | Enums with associated values | Partially: only support structs and enums                |
-| Enums with raw values        | No                                                       |
+| Enums with raw values        | Yes                                                       |
 | Indirect enums               | No                                                       |
 
 **Class types**
@@ -188,6 +188,7 @@ This status table describes which of the following Swift language features have
 | Getter accessors               | Yes, via `get<name>`. Boolean properties that start with `is` or `has` are remapped directly to a getter method using their original name                         |
 | Setter accessors               | Yes, via `set<name>`                                     |
 | Mutation accessors             | No                                                       |
+| Static property accessors      | Yes                         |
 
 **Generics**
 

docs/SIL.rst

@@ -3804,7 +3804,7 @@ debug_value
 
 ::
 
-  sil-instruction ::= debug_value '[poison]'? '[moved]'? sil-operand (',' debug-var-attr)* advanced-debug-var-attr* (',' 'expr' debug-info-expr)?
+  sil-instruction ::= debug_value '[poison]'? '[moved]'? '[trace]'? sil-operand (',' debug-var-attr)* advanced-debug-var-attr* (',' 'expr' debug-info-expr)?
 
   debug_value %1 : $Int
 
@@ -3910,6 +3910,8 @@ It is worth noting that a SIL DIExpression is similar to
 info metadata. While LLVM represents ``!DIExpression`` are a list of 64-bit integers,
 SIL DIExpression can have elements with various types, like AST nodes or strings.
 
+The ``[trace]`` flag is available for compiler unit testing. It is not produced during normal compilation. It is used combination with internal logging and optimization controls to select specific values to trace or to transform. For example, liveness analysis combines all "traced" values into a single live range with multiple definitions. This exposes corner cases that cannot be represented by passing valid SIL through the pipeline.
+
 Profiling
 ~~~~~~~~~
 

include/swift/AST/ASTScope.h

@@ -203,7 +203,7 @@ class ASTScopeImpl : public ASTAllocated<ASTScopeImpl> {
 
 #pragma mark common queries
 public:
-  virtual NullablePtr<ClosureExpr> getClosureIfClosureScope() const;
+  virtual NullablePtr<AbstractClosureExpr> getClosureIfClosureScope() const;
   virtual ASTContext &getASTContext() const;
   virtual NullablePtr<Decl> getDeclIfAny() const { return nullptr; };
   virtual NullablePtr<Stmt> getStmtIfAny() const { return nullptr; };
@@ -1032,17 +1032,17 @@ class CaptureListScope final : public ASTScopeImpl {
 /// For a closure with named parameters, this scope does the local bindings.
 class ClosureParametersScope final : public ASTScopeImpl {
 public:
-  ClosureExpr *const closureExpr;
+  AbstractClosureExpr *const closureExpr;
 
-  ClosureParametersScope(ClosureExpr *closureExpr)
+  ClosureParametersScope(AbstractClosureExpr *closureExpr)
       : closureExpr(closureExpr) {}
   virtual ~ClosureParametersScope() {}
 
   std::string getClassName() const override;
   SourceRange
   getSourceRangeOfThisASTNode(bool omitAssertions = false) const override;
 
-  NullablePtr<ClosureExpr> getClosureIfClosureScope() const override {
+  NullablePtr<AbstractClosureExpr> getClosureIfClosureScope() const override {
     return closureExpr;
   }
   NullablePtr<Expr> getExprIfAny() const override { return closureExpr; }
@@ -1541,7 +1541,7 @@ class BraceStmtScope final : public AbstractStmtScope {
   SourceRange
   getSourceRangeOfThisASTNode(bool omitAssertions = false) const override;
 
-  NullablePtr<ClosureExpr> parentClosureIfAny() const; // public??
+  NullablePtr<AbstractClosureExpr> parentClosureIfAny() const; // public??
   Stmt *getStmt() const override { return stmt; }
 
 protected:

include/swift/AST/Expr.h

@@ -4144,10 +4144,10 @@ class CaptureListExpr final : public Expr,
     private llvm::TrailingObjects<CaptureListExpr, CaptureListEntry> {
   friend TrailingObjects;
 
-  ClosureExpr *closureBody;
+  AbstractClosureExpr *closureBody;
 
   CaptureListExpr(ArrayRef<CaptureListEntry> captureList,
-                  ClosureExpr *closureBody)
+                  AbstractClosureExpr *closureBody)
     : Expr(ExprKind::CaptureList, /*Implicit=*/false, Type()),
       closureBody(closureBody) {
     Bits.CaptureListExpr.NumCaptures = captureList.size();
@@ -4158,16 +4158,16 @@ class CaptureListExpr final : public Expr,
 public:
   static CaptureListExpr *create(ASTContext &ctx,
                                  ArrayRef<CaptureListEntry> captureList,
-                                 ClosureExpr *closureBody);
+                                 AbstractClosureExpr *closureBody);
 
   ArrayRef<CaptureListEntry> getCaptureList() {
     return {getTrailingObjects<CaptureListEntry>(),
             Bits.CaptureListExpr.NumCaptures};
   }
-  ClosureExpr *getClosureBody() { return closureBody; }
-  const ClosureExpr *getClosureBody() const { return closureBody; }
+  AbstractClosureExpr *getClosureBody() { return closureBody; }
+  const AbstractClosureExpr *getClosureBody() const { return closureBody; }
 
-  void setClosureBody(ClosureExpr *body) { closureBody = body; }
+  void setClosureBody(AbstractClosureExpr *body) { closureBody = body; }
 
   /// This is a bit weird, but the capture list is lexically contained within
   /// the closure, so the ClosureExpr has the full source range.
@@ -5389,10 +5389,6 @@ class KeyPathExpr : public Expr {
   /// a contextual root type.
   bool HasLeadingDot = false;
 
-  /// When we parse a key path literal, we claim a closure discriminator for it, since it may be used as
-  /// a closure value in function type context.
-  unsigned ClosureDiscriminator;
-
 public:
   /// A single stored component, which will be one of:
   /// - an unresolved DeclNameRef, which has to be type-checked
@@ -5724,12 +5720,11 @@ class KeyPathExpr : public Expr {
 
   KeyPathExpr(SourceLoc startLoc, Expr *parsedRoot, Expr *parsedPath,
               SourceLoc endLoc, bool hasLeadingDot, bool isObjC,
-              bool isImplicit, unsigned closureDiscriminator);
+              bool isImplicit);
 
   /// Create a key path with unresolved root and path expressions.
   KeyPathExpr(SourceLoc backslashLoc, Expr *parsedRoot, Expr *parsedPath,
-              bool hasLeadingDot, bool isImplicit,
-              unsigned closureDiscriminator);
+              bool hasLeadingDot, bool isImplicit);
 
   /// Create a key path with components.
   KeyPathExpr(ASTContext &ctx, SourceLoc startLoc,
@@ -5740,8 +5735,7 @@ class KeyPathExpr : public Expr {
   /// Create a new parsed Swift key path expression.
   static KeyPathExpr *createParsed(ASTContext &ctx, SourceLoc backslashLoc,
      Expr *parsedRoot, Expr *parsedPath,
-     bool hasLeadingDot,
-     unsigned closureDiscriminator = AbstractClosureExpr::InvalidDiscriminator);
+     bool hasLeadingDot);
 
   /// Create a new parsed #keyPath expression.
   static KeyPathExpr *createParsedPoundKeyPath(ASTContext &ctx,
@@ -5836,9 +5830,6 @@ class KeyPathExpr : public Expr {
   /// True if this key path expression has a leading dot.
   bool expectsContextualRoot() const { return HasLeadingDot; }
 
-  /// Return the discriminator to use if this key path becomes a closure.
-  unsigned getClosureDiscriminator() const { return ClosureDiscriminator; }
-
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::KeyPath;
   }

include/swift/AST/Module.h

@@ -841,6 +841,8 @@ class ModuleDecl
     return EntryPointInfo.hasEntryPoint();
   }
 
+  NominalTypeDecl *getMainTypeDecl() const;
+
   /// Returns the associated clang module if one exists.
   const clang::Module *findUnderlyingClangModule() const;
 

include/swift/AST/PlatformKind.h

@@ -41,9 +41,10 @@ StringRef platformString(PlatformKind platform);
 /// or None if such a platform kind does not exist.
 Optional<PlatformKind> platformFromString(StringRef Name);
 
-/// Returns a valid platform string if the candidate string would be a valid
-/// platform string if its case were adjusted (e.g. "macos" -> "macOS").
-Optional<StringRef> caseCorrectedPlatformString(StringRef candidate);
+/// Returns a valid platform string that is closest to the candidate string
+/// based on edit distance. Returns \c None if the closest valid platform
+/// distance is not within a minimum threshold.
+Optional<StringRef> closestCorrectedPlatformString(StringRef candidate);
 
 /// Returns a human-readable version of the platform name as a string, suitable
 /// for emission in diagnostics (e.g., "macOS").

include/swift/AST/Types.h

@@ -4676,6 +4676,17 @@ class SILFunctionType final
   /// differentiability from all parameters.
   CanSILFunctionType getWithoutDifferentiability();
 
+  /// Given that `this` is a `@differentiable` function type, returns the type
+  /// of the given `@differentiable` function type component.
+  CanSILFunctionType getDifferentiableComponentType(
+      NormalDifferentiableFunctionTypeComponent component, SILModule &module);
+
+  /// Given that `this` is a `@differentiable(linear)` function type, returns
+  /// the type of the given `@differentiable(linear)` function type component.
+  CanSILFunctionType
+  getLinearComponentType(LinearDifferentiableFunctionTypeComponent component,
+                         SILModule &module);
+
   /// Returns the type of the derivative function for the given parameter
   /// indices, result indices, derivative function kind, derivative function
   /// generic signature (optional), and other auxiliary parameters.

include/swift/IDE/Utils.h

@@ -287,11 +287,8 @@ class NameMatcher: public ASTWalker {
   PreWalkResult<Expr *> walkToExprPre(Expr *E) override;
   PostWalkResult<Expr *> walkToExprPost(Expr *E) override;
   PreWalkAction walkToDeclPre(Decl *D) override;
-  PostWalkAction walkToDeclPost(Decl *D) override;
   PreWalkResult<Stmt *> walkToStmtPre(Stmt *S) override;
-  PostWalkResult<Stmt *> walkToStmtPost(Stmt *S) override;
   PreWalkAction walkToTypeReprPre(TypeRepr *T) override;
-  PostWalkAction walkToTypeReprPost(TypeRepr *T) override;
   PreWalkResult<Pattern *> walkToPatternPre(Pattern *P) override;
   bool shouldWalkIntoGenericParams() override { return true; }
 

include/swift/SIL/NodeDatastructures.h

@@ -0,0 +1,107 @@
+//===--- NodeDatastructures.h -----------------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines efficient data structures for working with Nodes.
+//
+// TODO: Add an InstructionWorklist similar to BasicBlockWorklist.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SIL_NODEDATASTRUCTURES_H
+#define SWIFT_SIL_NODEDATASTRUCTURES_H
+
+#include "swift/SIL/NodeBits.h"
+#include "swift/SIL/StackList.h"
+
+namespace swift {
+
+/// An implementation of `llvm::SetVector<SILNode *,
+///                                       StackList<SILNode *>,
+///                                       NodeSet>`.
+///
+/// Unfortunately it's not possible to use `llvm::SetVector` directly because
+/// the ValueSet and StackList constructors needs a `SILFunction` argument.
+///
+/// Note: This class does not provide a `remove` method intentionally, because
+/// it would have a O(n) complexity.
+class NodeSetVector {
+  StackList<SILNode *> vector;
+  NodeSet set;
+
+public:
+  using iterator = typename StackList<SILNode *>::iterator;
+
+  NodeSetVector(SILFunction *function) : vector(function), set(function) {}
+
+  iterator begin() const { return vector.begin(); }
+  iterator end() const { return vector.end(); }
+
+  llvm::iterator_range<iterator> getRange() const {
+    return llvm::make_range(begin(), end());
+  }
+
+  bool empty() const { return vector.empty(); }
+
+  bool contains(SILNode *node) const { return set.contains(node); }
+
+  /// Returns true if \p value was not contained in the set before inserting.
+  bool insert(SILNode *node) {
+    if (set.insert(node)) {
+      vector.push_back(node);
+      return true;
+    }
+    return false;
+  }
+};
+
+/// An implementation of `llvm::SetVector<SILValue,
+///                                       StackList<SILValue>,
+///                                       ValueSet>`.
+///
+/// Unfortunately it's not possible to use `llvm::SetVector` directly because
+/// the ValueSet and StackList constructors needs a `SILFunction` argument.
+///
+/// Note: This class does not provide a `remove` method intentionally, because
+/// it would have a O(n) complexity.
+class ValueSetVector {
+  StackList<SILValue> vector;
+  ValueSet set;
+
+public:
+  using iterator = typename StackList<SILValue>::iterator;
+
+  ValueSetVector(SILFunction *function) : vector(function), set(function) {}
+
+  iterator begin() const { return vector.begin(); }
+  iterator end() const { return vector.end(); }
+
+  llvm::iterator_range<iterator> getRange() const {
+    return llvm::make_range(begin(), end());
+  }
+
+  bool empty() const { return vector.empty(); }
+
+  bool contains(SILValue value) const { return set.contains(value); }
+
+  /// Returns true if \p value was not contained in the set before inserting.
+  bool insert(SILValue value) {
+    if (set.insert(value)) {
+      vector.push_back(value);
+      return true;
+    }
+    return false;
+  }
+};
+
+} // namespace swift
+
+#endif

include/swift/SIL/SILBasicBlock.h

@@ -659,4 +659,26 @@ template <> struct DenseMapInfo<swift::PhiValue> {
 
 } // end namespace llvm
 
+//===----------------------------------------------------------------------===//
+// Inline SILInstruction implementations
+//===----------------------------------------------------------------------===//
+
+namespace swift {
+
+inline SILFunction *SILInstruction::getFunction() const {
+  return getParent()->getParent();
+}
+
+inline SILInstruction *SILInstruction::getPreviousInstruction() {
+  auto pos = getIterator();
+  return pos == getParent()->begin() ? nullptr : &*std::prev(pos);
+}
+
+inline SILInstruction *SILInstruction::getNextInstruction() {
+  auto nextPos = std::next(getIterator());
+  return nextPos == getParent()->end() ? nullptr : &*nextPos;
+}
+
+} // end swift namespace
+
 #endif

include/swift/SIL/SILBuilder.h

@@ -957,10 +957,12 @@ class SILBuilder {
   DebugValueInst *createDebugValue(SILLocation Loc, SILValue src,
                                    SILDebugVariable Var,
                                    bool poisonRefs = false,
-                                   bool wasMoved = false);
+                                   bool wasMoved = false,
+                                   bool trace = false);
   DebugValueInst *createDebugValueAddr(SILLocation Loc, SILValue src,
                                        SILDebugVariable Var,
-                                       bool wasMoved = false);
+                                       bool wasMoved = false,
+                                       bool trace = false);
 
   /// Create a debug_value according to the type of \p src
   SILInstruction *emitDebugDescription(SILLocation Loc, SILValue src,

include/swift/SIL/SILCloner.h

@@ -1283,7 +1283,7 @@ SILCloner<ImplClass>::visitDebugValueInst(DebugValueInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   auto *NewInst = getBuilder().createDebugValue(
       Inst->getLoc(), getOpValue(Inst->getOperand()), VarInfo,
-      Inst->poisonRefs(), Inst->getWasMoved());
+      Inst->poisonRefs(), Inst->getWasMoved(), Inst->hasTrace());
   remapDebugVarInfo(DebugVarCarryingInst(NewInst));
   recordClonedInstruction(Inst, NewInst);
 }

include/swift/SIL/SILFunction.h

@@ -1461,4 +1461,20 @@ public ilist_node_traits<::swift::SILFunction> {
 
 } // end llvm namespace
 
+//===----------------------------------------------------------------------===//
+// Inline SIL implementations
+//===----------------------------------------------------------------------===//
+
+namespace swift {
+
+inline bool SILBasicBlock::isEntry() const {
+  return this == &*getParent()->begin();
+}
+
+inline SILModule &SILInstruction::getModule() const {
+  return getFunction()->getModule();
+}
+
+} // end swift namespace
+
 #endif