Merge pull request #5488 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

include/swift/AST/Attr.h

@@ -1551,25 +1551,28 @@ class SpecializeAttr final
 /// The @_implements attribute, which treats a decl as the implementation for
 /// some named protocol requirement (but otherwise not-visible by that name).
 class ImplementsAttr : public DeclAttribute {
-  TypeExpr *ProtocolType;
+  TypeRepr *TyR;
   DeclName MemberName;
   DeclNameLoc MemberNameLoc;
 
-public:
   ImplementsAttr(SourceLoc atLoc, SourceRange Range,
-                 TypeExpr *ProtocolType,
+                 TypeRepr *TyR,
                  DeclName MemberName,
                  DeclNameLoc MemberNameLoc);
 
+public:
   static ImplementsAttr *create(ASTContext &Ctx, SourceLoc atLoc,
                                 SourceRange Range,
-                                TypeExpr *ProtocolType,
+                                TypeRepr *TyR,
                                 DeclName MemberName,
                                 DeclNameLoc MemberNameLoc);
 
-  void setProtocolType(Type ty);
-  Type getProtocolType() const;
-  TypeRepr *getProtocolTypeRepr() const;
+  static ImplementsAttr *create(DeclContext *DC,
+                                ProtocolDecl *Proto,
+                                DeclName MemberName);
+
+  ProtocolDecl *getProtocol(DeclContext *dc) const;
+  TypeRepr *getProtocolTypeRepr() const { return TyR; }
 
   DeclName getMemberName() const { return MemberName; }
   DeclNameLoc getMemberNameLoc() const { return MemberNameLoc; }

include/swift/AST/DiagnosticsFrontend.def

@@ -195,11 +195,11 @@ ERROR(error_empty_package_name,none,
 ERROR(error_stdlib_not_found,Fatal,
       "unable to load standard library for target '%0'", (StringRef))
 ERROR(error_module_alias_invalid_format,none,
-      "invalid module alias format \"%0\"; make sure to use the format '-module-alias alias_name=underlying_name'", (StringRef))
+      "invalid module alias format \"%0\"; make sure to use the format '-module-alias alias_name=real_name'", (StringRef))
 ERROR(error_module_alias_forbidden_name,none,
       "invalid module alias \"%0\"; make sure the alias differs from the module name, module ABI name, module link name, and a standard library name", (StringRef))
 ERROR(error_module_alias_duplicate,none,
-      "duplicate module alias; the name \"%0\" is already used for a module alias or an underlying name", (StringRef))
+      "duplicate module alias; the name \"%0\" is already used for an alias or a real name", (StringRef))
 
 ERROR(error_unable_to_load_supplementary_output_file_map, none,
       "unable to load supplementary output file map '%0': %1",

include/swift/AST/Expr.h

@@ -3711,7 +3711,7 @@ class MaterializePackExpr final : public Expr {
   }
 
   SourceLoc getEndLoc() const {
-    return ElementLoc.isInvalid() ? ElementLoc : FromExpr->getEndLoc();
+    return ElementLoc.isValid() ? ElementLoc : FromExpr->getEndLoc();
   }
 
   static bool classof(const Expr *E) {

include/swift/AST/NameLookupRequests.h

@@ -22,6 +22,7 @@
 #include "swift/AST/FileUnit.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/NameLookup.h"
+#include "swift/AST/TypeOrExtensionDecl.h"
 #include "swift/Basic/Statistic.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/TinyPtrVector.h"
@@ -37,6 +38,7 @@ class GenericContext;
 class GenericParamList;
 class LookupResult;
 enum class NLKind;
+class PotentialMacroExpansions;
 class SourceLoc;
 class TypeAliasDecl;
 class TypeDecl;
@@ -889,6 +891,46 @@ class HasDynamicCallableAttributeRequest
   bool isCached() const { return true; }
 };
 
+/// Determine the potential macro expansions for a given type or extension
+/// context.
+class PotentialMacroExpansionsInContextRequest
+    : public SimpleRequest<
+          PotentialMacroExpansionsInContextRequest,
+          PotentialMacroExpansions(TypeOrExtensionDecl),
+          RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  PotentialMacroExpansions evaluate(
+      Evaluator &evaluator, TypeOrExtensionDecl container) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
+/// Resolves the protocol referenced by an @_implements attribute.
+class ImplementsAttrProtocolRequest
+    : public SimpleRequest<ImplementsAttrProtocolRequest,
+                           ProtocolDecl *(const ImplementsAttr *, DeclContext *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  ProtocolDecl *evaluate(Evaluator &evaluator, const ImplementsAttr *attr,
+                         DeclContext *dc) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 #define SWIFT_TYPEID_ZONE NameLookup
 #define SWIFT_TYPEID_HEADER "swift/AST/NameLookupTypeIDZone.def"
 #include "swift/Basic/DefineTypeIDZone.h"

include/swift/AST/NameLookupTypeIDZone.def

@@ -107,3 +107,7 @@ SWIFT_REQUEST(NameLookup, HasDynamicMemberLookupAttributeRequest,
               bool(NominalTypeDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(NameLookup, HasDynamicCallableAttributeRequest,
               bool(NominalTypeDecl *), Cached, NoLocationInfo)
+SWIFT_REQUEST(NameLookup, PotentialMacroExpansionsInContextRequest,
+              PotentialMacroExpansions(TypeOrExtension), Cached, NoLocationInfo)
+SWIFT_REQUEST(NameLookup, ImplementsAttrProtocolRequest,
+              ProtocolDecl *(const ImplementsAttr *, DeclContext *), Cached, NoLocationInfo)

include/swift/AST/PotentialMacroExpansions.h

@@ -0,0 +1,186 @@
+//===--- PotentialMacroExpansions.h -----------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 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 a structure (\c PotentialMacroExpansions) to track
+//  potential macro expansions within a given context.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SWIFT_AST_POTENTIAL_MACRO_EXPANSIONS_H
+#define SWIFT_AST_POTENTIAL_MACRO_EXPANSIONS_H
+
+#include "swift/AST/Identifier.h"
+#include "llvm/ADT/PointerIntPair.h"
+#include "llvm/ADT/SmallPtrSet.h"
+
+namespace swift {
+
+/// Describes the potential macro expansions within a given type or
+/// extension context.
+class PotentialMacroExpansions {
+  enum {
+    /// Whether there are any expanded macros.
+    AnyExpandedMacros = 0x01,
+
+    /// Whether any of the expanded macros introduces arbitrary names.
+    IntroducesArbitraryNames = 0x02,
+  };
+
+  using NameSet = llvm::SmallPtrSet<DeclName, 4>;
+
+  /// Storage for the set of potential macro expansions.
+  llvm::PointerIntPair<NameSet *, 2, unsigned> Storage;
+
+  /// Retrieve a pointer to the name set if there is one.
+  const NameSet *getIntroducedNamesIfAvailable() const {
+    return Storage.getPointer();
+  }
+
+  /// Get or create a nam
+  NameSet &getOrCreateIntroducedNames() {
+    if (auto nameSet = Storage.getPointer())
+      return *nameSet;
+
+    // Allocate a new set of introduced names.
+    auto nameSet = new NameSet();
+    Storage.setPointer(nameSet);
+    return *nameSet;
+  }
+
+public:
+  PotentialMacroExpansions() : Storage() { }
+
+  PotentialMacroExpansions(const PotentialMacroExpansions &other)
+    : Storage(nullptr, other.Storage.getInt())
+  {
+    if (auto otherNameSet = other.getIntroducedNamesIfAvailable()) {
+      Storage.setPointer(new NameSet(*otherNameSet));
+    }
+  }
+
+  PotentialMacroExpansions(PotentialMacroExpansions &&other)
+    : Storage(other.Storage)
+  {
+    other.Storage.setPointer(nullptr);
+  }
+
+  PotentialMacroExpansions &operator=(const PotentialMacroExpansions &other) {
+    PotentialMacroExpansions tmp(other);
+    swap(tmp, *this);
+    return *this;
+  }
+
+  PotentialMacroExpansions &operator=(PotentialMacroExpansions &&other) {
+    if (&other != this) {
+      Storage = other.Storage;
+      other.Storage.setPointer(nullptr);
+    }
+    return *this;
+  }
+
+  ~PotentialMacroExpansions() {
+    delete getIntroducedNamesIfAvailable();
+  }
+
+  /// Whether there are any expanded macros in this context.
+  explicit operator bool() const { return hasAnyExpandedMacro(); }
+
+  /// Whether there are any expanded macros in this context.
+  bool hasAnyExpandedMacro() const {
+    return Storage.getInt() & AnyExpandedMacros;
+  }
+
+  /// Note that we have expanded a macro.
+  void noteExpandedMacro() {
+    Storage.setInt(Storage.getInt() | AnyExpandedMacros);
+  }
+
+  /// Whether any expanded macro introduces arbitrary names.
+  bool introducesArbitraryNames() const {
+    return Storage.getInt() & IntroducesArbitraryNames;
+  }
+
+  /// Note that a macro expanded here introduced arbitrary names.
+  void noteIntroducesArbitraryNames() {
+    Storage.setInt(Storage.getInt() | IntroducesArbitraryNames);
+  }
+
+  /// Add a new introduced macro name.
+  void addIntroducedMacroName(DeclName name) {
+    getOrCreateIntroducedNames().insert(name.getBaseName());
+  }
+
+  /// Determine whether one should expand any macros in this context because
+  /// they could introduce a declaration with the given name.
+  bool shouldExpandForName(DeclName name) const {
+    // If any macro produces arbitraty names, we need to expand it.
+    if (introducesArbitraryNames())
+      return true;
+
+    auto introducedNames = getIntroducedNamesIfAvailable();
+    if (!introducedNames)
+      return false;
+
+    return introducedNames->count(name.getBaseName());
+  }
+
+  friend bool operator==(const PotentialMacroExpansions &lhs,
+                         const PotentialMacroExpansions &rhs) {
+    // Check has-any-expanded-macro and introduces-arbitrary-names together.
+    if (lhs.Storage.getInt() != rhs.Storage.getInt())
+      return false;
+
+    // If they introduced arbitrary names, ignore the name sets... they are
+    // the same.
+    if (lhs.introducesArbitraryNames())
+      return true;
+
+    // Both expanded macros and did not introduce arbitrary names, so we need
+    // to check the actual names.
+    auto lhsIntroducedNames = lhs.getIntroducedNamesIfAvailable();
+    auto rhsIntroducedNames = rhs.getIntroducedNamesIfAvailable();
+
+    auto lhsIntroducedNamesCount =
+        lhsIntroducedNames ? lhsIntroducedNames->size() : 0;
+    auto rhsIntroducedNamesCount =
+        rhsIntroducedNames ? rhsIntroducedNames->size() : 0;
+    if (lhsIntroducedNamesCount != rhsIntroducedNamesCount)
+      return false;
+
+    // Check whether both are empty.
+    if (lhsIntroducedNamesCount == 0)
+      return true;
+
+    // Make sure all of the names of one are in the other.
+    for (auto lhsName : *lhsIntroducedNames) {
+      if (rhsIntroducedNames->count(lhsName) == 0)
+        return false;
+    }
+
+    return true;
+  }
+
+  friend bool operator!=(const PotentialMacroExpansions &lhs,
+                         const PotentialMacroExpansions &rhs) {
+    return !(lhs == rhs);
+  }
+
+  friend void swap(
+      PotentialMacroExpansions &lhs, PotentialMacroExpansions &rhs) {
+    auto tmpStorage = lhs.Storage;
+    lhs.Storage = rhs.Storage;
+    rhs.Storage = tmpStorage;
+  }
+};
+
+}
+
+#endif // SWIFT_AST_POTENTIAL_MACRO_EXPANSIONS_H

include/swift/AST/TypeOrExtensionDecl.h

@@ -21,8 +21,13 @@
 #include "swift/AST/TypeAlignments.h"
 #include "llvm/ADT/PointerUnion.h"
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace swift {
 
+class SourceLoc;
 class DeclContext;
 class IterableDeclContext;
 
@@ -51,11 +56,23 @@ struct TypeOrExtensionDecl {
   bool isNull() const;
   explicit operator bool() const { return !isNull(); }
 
-  bool operator==(TypeOrExtensionDecl rhs) { return Decl == rhs.Decl; }
-  bool operator!=(TypeOrExtensionDecl rhs) { return Decl != rhs.Decl; }
-  bool operator<(TypeOrExtensionDecl rhs) { return Decl < rhs.Decl; }
+  friend bool operator==(TypeOrExtensionDecl lhs, TypeOrExtensionDecl rhs) {
+    return lhs.Decl == rhs.Decl;
+  }
+  friend bool operator!=(TypeOrExtensionDecl lhs, TypeOrExtensionDecl rhs) {
+    return lhs.Decl != rhs.Decl;
+  }
+  friend bool operator<(TypeOrExtensionDecl lhs, TypeOrExtensionDecl rhs) {
+    return lhs.Decl < rhs.Decl;
+  }
+  friend llvm::hash_code hash_value(TypeOrExtensionDecl decl) {
+    return llvm::hash_value(decl.getAsDecl());
+  }
 };
 
+void simple_display(llvm::raw_ostream &out, TypeOrExtensionDecl container);
+SourceLoc extractNearestSourceLoc(TypeOrExtensionDecl container);
+
 } // end namespace swift
 
 #endif

include/swift/AST/Types.h

@@ -6414,7 +6414,7 @@ class PackArchetypeType final
       LayoutConstraint Layout);
 
   // Returns the reduced shape type for this pack archetype.
-  CanType getReducedShape() const;
+  CanType getReducedShape();
 
   static bool classof(const TypeBase *T) {
     return T->getKind() == TypeKind::PackArchetype;
@@ -7098,16 +7098,6 @@ inline bool TypeBase::isTypeParameter() {
   return t->is<GenericTypeParamType>();
 }
 
-inline bool TypeBase::isParameterPack() {
-  Type t(this);
-
-  while (auto *memberTy = t->getAs<DependentMemberType>())
-    t = memberTy->getBase();
-
-  return t->is<GenericTypeParamType>() &&
-         t->castTo<GenericTypeParamType>()->isParameterPack();
-}
-
 // TODO: This will become redundant once InOutType is removed.
 inline bool TypeBase::isMaterializable() {
   return !(hasLValueType() || is<InOutType>());

include/swift/Basic/Features.def

@@ -116,7 +116,6 @@ UPCOMING_FEATURE(ExistentialAny, 335, 6)
 UPCOMING_FEATURE(ImportObjcForwardDeclarations, 384, 6)
 
 EXPERIMENTAL_FEATURE(StaticAssert, false)
-EXPERIMENTAL_FEATURE(VariadicGenerics, false)
 EXPERIMENTAL_FEATURE(NamedOpaqueTypes, false)
 EXPERIMENTAL_FEATURE(FlowSensitiveConcurrencyCaptures, false)
 EXPERIMENTAL_FEATURE(CodeItemMacros, true)