Merge branch 'master' into extend-operator-designated-type

Author: rudkx

benchmark/single-source/NSStringConversion.swift

@@ -23,7 +23,7 @@ public func run_NSStringConversion(_ N: Int) {
 #if _runtime(_ObjC)
 let test:NSString = NSString(cString: "test", encoding: String.Encoding.ascii.rawValue)!
   for _ in 1...N * 10000 {
-    _ = test as String
+    blackHole(identity(test) as String)
   }
 #endif
 }

include/swift/AST/ASTContext.h

@@ -400,12 +400,35 @@ class ASTContext final {
   /// Set a new stats reporter.
   void setStatsReporter(UnifiedStatsReporter *stats);
 
+  /// Creates a new lazy resolver by passing the ASTContext and the other
+  /// given arguments to a newly-allocated instance of \c ResolverType.
+  ///
+  /// \returns true if a new lazy resolver was created, false if there was
+  /// already a lazy resolver registered.
+  template<typename ResolverType, typename ... Args>
+  bool createLazyResolverIfMissing(Args && ...args) {
+    if (getLazyResolver())
+      return false;
+
+    setLazyResolver(new ResolverType(*this, std::forward<Args>(args)...));
+    return true;
+  }
+
+  /// Remove the lazy resolver, if there is one.
+  ///
+  /// FIXME: We probably don't ever want to do this.
+  void removeLazyResolver() {
+    setLazyResolver(nullptr);
+  }
+
   /// Retrieve the lazy resolver for this context.
   LazyResolver *getLazyResolver() const;
 
+private:
   /// Set the lazy resolver for this context.
   void setLazyResolver(LazyResolver *resolver);
 
+public:
   /// Add a lazy parser for resolving members later.
   void addLazyParser(LazyMemberParser *parser);
 

include/swift/AST/AttrKind.h

@@ -40,6 +40,9 @@ enum class Associativity : uint8_t {
   Right
 };
 
+/// Returns the in-source spelling of the given associativity.
+StringRef getAssociativitySpelling(Associativity value);
+
 /// The kind of unary operator, if any.
 enum class UnaryOperatorKind : uint8_t {
   None,

include/swift/AST/Builtins.def

@@ -114,6 +114,8 @@ BUILTIN_UNARY_OPERATION(FNeg, "fneg", "n", FloatOrVector)
 // It has only an effect if the argument is a load or call.
 // TODO: consider printing a warning if it is not used on a load or call.
 BUILTIN_UNARY_OPERATION(AssumeNonNegative, "assumeNonNegative", "n", Integer)
+// It only works on i1.
+BUILTIN_UNARY_OPERATION(AssumeTrue, "assume", "", Integer)
 
 #undef BUILTIN_UNARY_OPERATION
 

include/swift/AST/Module.h

@@ -431,6 +431,12 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   /// The order of the results is not guaranteed to be meaningful.
   void getLocalTypeDecls(SmallVectorImpl<TypeDecl*> &Results) const;
 
+  /// Finds all precedence group decls of this module.
+  ///
+  /// This does a simple local lookup, not recursively looking through imports.
+  /// The order of the results is not guaranteed to be meaningful.
+  void getPrecedenceGroups(SmallVectorImpl<PrecedenceGroupDecl*> &Results) const;
+
   /// Finds all top-level decls that should be displayed to a client of this
   /// module.
   ///
@@ -690,6 +696,13 @@ class FileUnit : public DeclContext {
   virtual void getTopLevelDecls(SmallVectorImpl<Decl*> &results) const {}
 
 
+  /// Finds all precedence group decls in this file.
+  ///
+  /// This does a simple local lookup, not recursively looking through imports.
+  /// The order of the results is not guaranteed to be meaningful.
+  virtual void
+  getPrecedenceGroups(SmallVectorImpl<PrecedenceGroupDecl*> &Results) const {}
+
   /// Finds all local type decls in this file.
   ///
   /// This does a simple local lookup, not recursively looking through imports.
@@ -985,6 +998,9 @@ class SourceFile final : public FileUnit {
 
   virtual void getTopLevelDecls(SmallVectorImpl<Decl*> &results) const override;
 
+  virtual void
+  getPrecedenceGroups(SmallVectorImpl<PrecedenceGroupDecl*> &results) const override;
+
   virtual void
   getLocalTypeDecls(SmallVectorImpl<TypeDecl*> &results) const override;
 

include/swift/Driver/Compilation.h

@@ -180,10 +180,6 @@ class Compilation {
   /// by \c BatchCount.
   const Optional<unsigned> BatchSizeLimit;
 
-  /// In order to test repartitioning, set to true if
-  /// -driver-force-one-batch-repartition is present.
-  const bool ForceOneBatchRepartition = false;
-
   /// True if temporary files should not be deleted.
   const bool SaveTemps;
 
@@ -236,7 +232,6 @@ class Compilation {
               unsigned BatchSeed = 0,
               Optional<unsigned> BatchCount = None,
               Optional<unsigned> BatchSizeLimit = None,
-              bool ForceOneBatchRepartition = false,
               bool SaveTemps = false,
               bool ShowDriverTimeCompilation = false,
               std::unique_ptr<UnifiedStatsReporter> Stats = nullptr);
@@ -298,8 +293,6 @@ class Compilation {
     return EnableBatchMode;
   }
 
-  bool getForceOneBatchRepartition() const { return ForceOneBatchRepartition; }
-
   bool getContinueBuildingAfterErrors() const {
     return ContinueBuildingAfterErrors;
   }

include/swift/IDE/CodeCompletion.h

@@ -508,6 +508,7 @@ enum class CompletionKind {
   PlatformConditon,
   AfterIfStmtElse,
   GenericParams,
+  PrecedenceGroup,
 };
 
 /// \brief A single code completion result.
@@ -891,7 +892,8 @@ void lookupCodeCompletionResultsFromModule(CodeCompletionResultSink &targetSink,
 /// restricting by \p onlyTypes.
 void copyCodeCompletionResults(CodeCompletionResultSink &targetSink,
                                CodeCompletionResultSink &sourceSink,
-                               bool onlyTypes);
+                               bool onlyTypes,
+                               bool onlyPrecedenceGroups);
 
 } // end namespace ide
 } // end namespace swift

include/swift/IDE/CodeCompletionCache.h

@@ -95,6 +95,7 @@ struct RequestedCachedModule {
   CodeCompletionCache::Key Key;
   const ModuleDecl *TheModule;
   bool OnlyTypes;
+  bool OnlyPrecedenceGroups;
 };
 
 } // end namespace ide

include/swift/Option/Options.td

@@ -116,9 +116,6 @@ def driver_batch_count : Separate<["-"], "driver-batch-count">,
 def driver_batch_size_limit : Separate<["-"], "driver-batch-size-limit">,
   InternalDebugOpt,
   HelpText<"Use the given number as the upper limit on dynamic batch-mode partition size">;
-def driver_force_one_batch_repartition : Flag<["-"], "driver-force-one-batch-repartition">,
-  InternalDebugOpt,
-  HelpText<"Force one batch repartitioning for testing">;
 
 def driver_force_response_files : Flag<["-"], "driver-force-response-files">,
   InternalDebugOpt,

include/swift/Parse/CodeCompletionCallbacks.h

@@ -183,6 +183,10 @@ class CodeCompletionCallbacks {
   /// @available.
   virtual void completeDeclAttrParam(DeclAttrKind DK, int Index) = 0;
 
+  /// Complete within a precedence group decl or after a colon in an
+  /// operator decl.
+  virtual void completeInPrecedenceGroup(SyntaxKind SK) = 0;
+
   /// Complete the platform names inside #available statements.
   virtual void completePoundAvailablePlatform() = 0;
 

include/swift/Parse/SyntaxParsingContext.h

@@ -331,8 +331,8 @@ class alignas(1 << SyntaxAlignInBits) SyntaxParsingContext {
   /// are supported. See the implementation.
   void createNodeInPlace(SyntaxKind Kind);
 
-  /// Squshing nodes from the back of the pending syntax list to a given syntax
-  /// collection kind. If there're no nodes can fit into the collection kind,
+  /// Squashing nodes from the back of the pending syntax list to a given syntax
+  /// collection kind. If there're no nodes that can fit into the collection kind,
   /// this function does nothing. Otherwise, it creates a collection node in place
   /// to contain all sequential suitable nodes from back.
   void collectNodesInPlace(SyntaxKind ColletionKind);

include/swift/SIL/OwnershipUtils.h

@@ -14,6 +14,7 @@
 #define SWIFT_SIL_OWNERSHIPUTILS_H
 
 #include "swift/Basic/LLVM.h"
+#include "swift/SIL/SILValue.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 
@@ -101,6 +102,22 @@ bool valueHasLinearLifetime(SILValue value,
                             DeadEndBlocks &deadEndBlocks,
                             ownership::ErrorBehaviorKind errorBehavior);
 
+/// Returns true if v is an address or trivial.
+bool isValueAddressOrTrivial(SILValue v, SILModule &m);
+
+/// These operations forward both owned and guaranteed ownership.
+bool isOwnershipForwardingValueKind(SILNodeKind kind);
+
+/// These operations forward guaranteed ownership, but don't necessarily forward
+/// owned values.
+bool isGuaranteedForwardingValueKind(SILNodeKind kind);
+
+bool isGuaranteedForwardingValue(SILValue value);
+
+bool isGuaranteedForwardingInst(SILInstruction *i);
+
+bool isOwnershipForwardingInst(SILInstruction *i);
+
 } // namespace swift
 
 #endif

include/swift/Sema/IDETypeChecking.h

@@ -30,6 +30,7 @@ namespace swift {
   class ExtensionDecl;
   class ProtocolDecl;
   class Type;
+  class TypeChecker;
   class DeclContext;
   class ConcreteDeclRef;
   class ValueDecl;
@@ -123,11 +124,11 @@ namespace swift {
   /// \returns true on success, false on error.
   bool typeCheckTopLevelCodeDecl(TopLevelCodeDecl *TLCD);
 
-  /// A unique_ptr for LazyResolver that can perform additional cleanup.
-  using OwnedResolver = std::unique_ptr<LazyResolver, void(*)(LazyResolver*)>;
-
-  /// Creates a lazy type resolver for use in lookups.
-  OwnedResolver createLazyResolver(ASTContext &Ctx);
+  /// Creates a type checker instance on the given AST context, if it
+  /// doesn't already have one.
+  ///
+  /// \returns a reference to the type checker instance.
+  TypeChecker &createTypeChecker(ASTContext &Ctx);
 
   struct ExtensionInfo {
     // The extension with the declarations to apply.

include/swift/Serialization/ModuleFile.h

@@ -738,6 +738,9 @@ class ModuleFile
   /// Adds all top-level decls to the given vector.
   void getTopLevelDecls(SmallVectorImpl<Decl*> &Results);
 
+  /// Adds all precedence groups to the given vector.
+  void getPrecedenceGroups(SmallVectorImpl<PrecedenceGroupDecl*> &Results);
+
   /// Adds all local type decls to the given vector.
   void getLocalTypeDecls(SmallVectorImpl<TypeDecl*> &Results);
 

include/swift/Serialization/SerializedModuleLoader.h

@@ -175,6 +175,9 @@ class SerializedASTFile final : public LoadedFile {
 
   virtual void getTopLevelDecls(SmallVectorImpl<Decl*> &results) const override;
 
+  virtual void
+  getPrecedenceGroups(SmallVectorImpl<PrecedenceGroupDecl*> &Results) const override;
+
   virtual void
   getLocalTypeDecls(SmallVectorImpl<TypeDecl*> &results) const override;
 

lib/AST/ASTContext.cpp

@@ -428,6 +428,8 @@ FOR_KNOWN_FOUNDATION_TYPES(CACHE_FOUNDATION_DECL)
 ASTContext::Implementation::Implementation()
     : IdentifierTable(Allocator), TheSyntaxArena(new SyntaxArena()) {}
 ASTContext::Implementation::~Implementation() {
+  delete Resolver;
+
   for (auto &cleanup : Cleanups)
     cleanup();
 }
@@ -579,13 +581,10 @@ LazyResolver *ASTContext::getLazyResolver() const {
 
 /// Set the lazy resolver for this context.
 void ASTContext::setLazyResolver(LazyResolver *resolver) {
-  if (resolver) {
-    assert(getImpl().Resolver == nullptr && "already have a resolver");
-    getImpl().Resolver = resolver;
-  } else {
-    assert(getImpl().Resolver != nullptr && "no resolver to remove");
-    getImpl().Resolver = resolver;
-  }
+  if (auto existing = getImpl().Resolver)
+    delete existing;
+
+  getImpl().Resolver = resolver;
 }
 
 void ASTContext::addLazyParser(LazyMemberParser *lazyParser) {

lib/AST/Decl.cpp

@@ -6062,6 +6062,15 @@ SourceRange DestructorDecl::getSourceRange() const {
   return { getDestructorLoc(), getBody()->getEndLoc() };
 }
 
+StringRef swift::getAssociativitySpelling(Associativity value) {
+  switch (value) {
+  case Associativity::None: return "none";
+  case Associativity::Left: return "left";
+  case Associativity::Right: return "right";
+  }
+  llvm_unreachable("Unhandled Associativity in switch.");
+}
+
 PrecedenceGroupDecl *
 PrecedenceGroupDecl::create(DeclContext *dc,
                             SourceLoc precedenceGroupLoc,

lib/AST/Module.cpp

@@ -547,6 +547,20 @@ void SourceFile::getTopLevelDecls(SmallVectorImpl<Decl*> &Results) const {
   Results.append(Decls.begin(), Decls.end());
 }
 
+void ModuleDecl::getPrecedenceGroups(
+       SmallVectorImpl<PrecedenceGroupDecl*> &Results) const {
+  FORWARD(getPrecedenceGroups, (Results));
+}
+
+void SourceFile::getPrecedenceGroups(
+       SmallVectorImpl<PrecedenceGroupDecl*> &Results) const {
+  for (auto pair : PrecedenceGroups) {
+    if (pair.second.getPointer() && pair.second.getInt()) {
+      Results.push_back(pair.second.getPointer());
+    }
+  }
+}
+
 void SourceFile::getLocalTypeDecls(SmallVectorImpl<TypeDecl*> &Results) const {
   Results.append(LocalTypeDecls.begin(), LocalTypeDecls.end());
 }

lib/AST/ProtocolConformance.cpp

@@ -578,7 +578,8 @@ NormalProtocolConformance::populateSignatureConformances() {
 
       // Allocate the buffer of conformance requirements.
       auto &ctx = self->getProtocol()->getASTContext();
-      buffer = ctx.AllocateUninitialized<ProtocolConformanceRef>(numConformanceRequirements);
+      buffer = ctx.AllocateUninitialized<ProtocolConformanceRef>(
+          numConformanceRequirements);
 
       // Skip over any non-conformance requirements in the requirement
       // signature.
@@ -600,11 +601,20 @@ NormalProtocolConformance::populateSignatureConformances() {
       other.owning = false;
     }
 
+    ~Writer() {
+      if (!owning)
+        return;
+      while (!requirementSignature.empty())
+        (*this)(ProtocolConformanceRef::forInvalid());
+    }
+
     void operator()(ProtocolConformanceRef conformance){
       // Make sure we have the right conformance.
       assert(!requirementSignature.empty() && "Too many conformances?");
-      assert(conformance.getRequirement() ==
-               requirementSignature.front().getSecondType()->castTo<ProtocolType>()->getDecl());
+      assert(conformance.isInvalid() ||
+             conformance.getRequirement() ==
+                 requirementSignature.front().getSecondType()
+                     ->castTo<ProtocolType>()->getDecl());
       assert((!conformance.isConcrete() ||
               !conformance.getConcrete()->getType()->hasArchetype()) &&
              "signature conformances must use interface types");