Merge branch 'master_final' into tensorflow-merge

Author: asuhan

cmake/modules/CMakeLists.txt

@@ -16,4 +16,4 @@ set(SWIFT_LIBRARY_DIRS ${SWIFT_LIBRARY_OUTPUT_INTDIR})
 configure_file(
   SwiftConfig.cmake.in
   ${swift_cmake_builddir}/SwiftConfig.cmake
-  @ONLY)
+  @ONLY)

cmake/modules/SwiftConfig.cmake.in

@@ -6,13 +6,13 @@ set(SWIFT_VERSION @SWIFT_VERSION@)
 set(SWIFT_MAIN_SRC_DIR @SWIFT_SOURCE_DIR@)
 
 set(SWIFT_INCLUDE_DIRS "@SWIFT_INCLUDE_DIRS@")
-set(SWIFT_LIBRARY_DIRS "@SWIFT_CONFIG_LIBRARY_DIRS@")
+set(SWIFT_LIBRARY_DIRS "@SWIFT_LIBRARY_DIRS@")
 
 # These variables are duplicated, but they must match the LLVM variables of the
 # same name. The variables ending in "S" could some day become lists, and are
 # preserved for convention and compatibility.
 set(SWIFT_INCLUDE_DIR "@SWIFT_INCLUDE_DIRS@")
-set(SWIFT_LIBRARY_DIR "@SWIFT_CONFIG_LIBRARY_DIRS@")
+set(SWIFT_LIBRARY_DIR "@SWIFT_LIBRARY_DIRS@")
 
 set(SWIFT_CMAKE_DIR "@SWIFT_CMAKE_DIR@")
 set(SWIFT_BINARY_DIR "@SWIFT_BINARY_DIR@")

include/swift/AST/Decl.h

@@ -388,7 +388,7 @@ class alignas(1 << DeclAlignInBits) Decl {
   SWIFT_INLINE_BITFIELD(SubscriptDecl, VarDecl, 2,
     StaticSpelling : 2
   );
-  SWIFT_INLINE_BITFIELD(AbstractFunctionDecl, ValueDecl, 3+8+1+1+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(AbstractFunctionDecl, ValueDecl, 3+8+1+1+1+1+1+1,
     /// \see AbstractFunctionDecl::BodyKind
     BodyKind : 3,
 
@@ -404,12 +404,6 @@ class alignas(1 << DeclAlignInBits) Decl {
     /// Whether the function body throws.
     Throws : 1,
 
-    /// Whether this function requires a new vtable entry.
-    NeedsNewVTableEntry : 1,
-
-    /// Whether NeedsNewVTableEntry is valid.
-    HasComputedNeedsNewVTableEntry : 1,
-
     /// Whether this member was synthesized as part of a derived
     /// protocol conformance.
     Synthesized : 1,
@@ -418,7 +412,10 @@ class alignas(1 << DeclAlignInBits) Decl {
     HasSingleExpressionBody : 1
   );
 
-  SWIFT_INLINE_BITFIELD(FuncDecl, AbstractFunctionDecl, 1+2+1+1+2,
+  SWIFT_INLINE_BITFIELD(FuncDecl, AbstractFunctionDecl, 1+1+2+1+1+2,
+    /// Whether we've computed the 'static' flag yet.
+    IsStaticComputed : 1,
+
     /// Whether this function is a 'static' method.
     IsStatic : 1,
 
@@ -854,17 +851,6 @@ class alignas(1 << DeclAlignInBits) Decl {
     return getValidationState() > ValidationState::Unchecked;
   }
 
-  /// Manually indicate that validation is complete for the declaration. For
-  /// example: during importing, code synthesis, or derived conformances.
-  ///
-  /// For normal code validation, please use DeclValidationRAII instead.
-  ///
-  /// FIXME -- Everything should use DeclValidationRAII instead of this.
-  void setValidationToChecked() {
-    if (!isBeingValidated())
-      Bits.Decl.ValidationState = unsigned(ValidationState::Checked);
-  }
-
   bool escapedFromIfConfig() const {
     return Bits.Decl.EscapedFromIfConfig;
   }
@@ -2605,6 +2591,9 @@ class ValueDecl : public Decl {
   /// if the base declaration is \c open, the override might have to be too.
   bool hasOpenAccess(const DeclContext *useDC) const;
 
+  /// FIXME: This is deprecated.
+  bool isRecursiveValidation() const;
+
   /// Retrieve the "interface" type of this value, which uses
   /// GenericTypeParamType if the declaration is generic. For a generic
   /// function, this will have a GenericFunctionType with a
@@ -5582,6 +5571,8 @@ class ImportAsMemberStatus {
 
 /// Base class for function-like declarations.
 class AbstractFunctionDecl : public GenericContext, public ValueDecl {
+  friend class NeedsNewVTableEntryRequest;
+
 public:
   enum class BodyKind {
     /// The function did not have a body in the source code file.
@@ -5651,6 +5642,11 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Location of the 'throws' token.
   SourceLoc ThrowsLoc;
 
+  struct {
+    unsigned NeedsNewVTableEntryComputed : 1;
+    unsigned NeedsNewVTableEntry : 1;
+  } LazySemanticInfo = { };
+
   AbstractFunctionDecl(DeclKind Kind, DeclContext *Parent, DeclName Name,
                        SourceLoc NameLoc, bool Throws, SourceLoc ThrowsLoc,
                        bool HasImplicitSelfDecl,
@@ -5662,8 +5658,6 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     Bits.AbstractFunctionDecl.HasImplicitSelfDecl = HasImplicitSelfDecl;
     Bits.AbstractFunctionDecl.Overridden = false;
     Bits.AbstractFunctionDecl.Throws = Throws;
-    Bits.AbstractFunctionDecl.NeedsNewVTableEntry = false;
-    Bits.AbstractFunctionDecl.HasComputedNeedsNewVTableEntry = false;
     Bits.AbstractFunctionDecl.Synthesized = false;
     Bits.AbstractFunctionDecl.HasSingleExpressionBody = false;
   }
@@ -5833,16 +5827,9 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     return getBodyKind() == BodyKind::MemberwiseInitializer;
   }
 
-  void setNeedsNewVTableEntry(bool value) {
-    Bits.AbstractFunctionDecl.HasComputedNeedsNewVTableEntry = true;
-    Bits.AbstractFunctionDecl.NeedsNewVTableEntry = value;
-  }
-
-  bool needsNewVTableEntry() const {
-    if (!Bits.AbstractFunctionDecl.HasComputedNeedsNewVTableEntry)
-      const_cast<AbstractFunctionDecl *>(this)->computeNeedsNewVTableEntry();
-    return Bits.AbstractFunctionDecl.NeedsNewVTableEntry;
-  }
+  /// For a method of a class, checks whether it will require a new entry in the
+  /// vtable.
+  bool needsNewVTableEntry() const;
 
   bool isEffectiveLinkageMoreVisibleThan(ValueDecl *other) const {
     return (std::min(getEffectiveAccess(), AccessLevel::Public) >
@@ -5984,6 +5971,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, SelfAccessKind SAK);
 class FuncDecl : public AbstractFunctionDecl {
   friend class AbstractFunctionDecl;
   friend class SelfAccessKindRequest;
+  friend class IsStaticRequest;
 
   SourceLoc StaticLoc;  // Location of the 'static' token or invalid.
   SourceLoc FuncLoc;    // Location of the 'func' token.
@@ -6005,14 +5993,14 @@ class FuncDecl : public AbstractFunctionDecl {
       StaticLoc(StaticLoc), FuncLoc(FuncLoc) {
     assert(!Name.getBaseName().isSpecial());
 
-    Bits.FuncDecl.IsStatic =
-      StaticLoc.isValid() || StaticSpelling != StaticSpellingKind::None;
     Bits.FuncDecl.StaticSpelling = static_cast<unsigned>(StaticSpelling);
 
     Bits.FuncDecl.ForcedStaticDispatch = false;
     Bits.FuncDecl.SelfAccess =
       static_cast<unsigned>(SelfAccessKind::NonMutating);
     Bits.FuncDecl.SelfAccessComputed = false;
+    Bits.FuncDecl.IsStaticComputed = false;
+    Bits.FuncDecl.IsStatic = false;
   }
 
 private:
@@ -6032,6 +6020,13 @@ class FuncDecl : public AbstractFunctionDecl {
     return None;
   }
 
+  Optional<bool> getCachedIsStatic() const {
+    if (Bits.FuncDecl.IsStaticComputed)
+      return Bits.FuncDecl.IsStatic;
+
+    return None;
+  }
+
 public:
   /// Factory function only for use by deserialization.
   static FuncDecl *createDeserialized(ASTContext &Context, SourceLoc StaticLoc,
@@ -6054,19 +6049,19 @@ class FuncDecl : public AbstractFunctionDecl {
 
   Identifier getName() const { return getFullName().getBaseIdentifier(); }
 
-  bool isStatic() const {
-    return Bits.FuncDecl.IsStatic;
-  }
+  bool isStatic() const;
   bool isCallable() const {
     return getName().str() == "callAsFunction" && isInstanceMember();
   }
+
   /// \returns the way 'static'/'class' was spelled in the source.
   StaticSpellingKind getStaticSpelling() const {
     return static_cast<StaticSpellingKind>(Bits.FuncDecl.StaticSpelling);
   }
   /// \returns the way 'static'/'class' should be spelled for this declaration.
   StaticSpellingKind getCorrectStaticSpelling() const;
   void setStatic(bool IsStatic = true) {
+    Bits.FuncDecl.IsStaticComputed = true;
     Bits.FuncDecl.IsStatic = IsStatic;
   }
 

include/swift/AST/DiagnosticsSema.def

@@ -381,7 +381,7 @@ ERROR(cannot_convert_argument_value,none,
       (Type,Type))
 
 NOTE(candidate_has_invalid_argument_at_position,none,
-     "candidate expects value of type %0 at position #%1",
+     "candidate expects value of type %0 for parameter #%1",
      (Type, unsigned))
 
 ERROR(cannot_convert_array_to_variadic,none,

include/swift/AST/TypeCheckRequests.h

@@ -1299,6 +1299,49 @@ class OpaqueResultTypeRequest
   bool isCached() const { return true; }
 };
 
+/// Determines if a function declaration is 'static'.
+class IsStaticRequest :
+    public SimpleRequest<IsStaticRequest,
+                         bool(FuncDecl *),
+                         CacheKind::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<bool>
+  evaluate(Evaluator &evaluator, FuncDecl *value) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<bool> getCachedResult() const;
+  void cacheResult(bool value) const;
+};
+
+class NeedsNewVTableEntryRequest
+    : public SimpleRequest<NeedsNewVTableEntryRequest,
+                           bool(AbstractFunctionDecl *),
+                           CacheKind::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<bool> evaluate(Evaluator &evaluator,
+                                AbstractFunctionDecl *decl) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<bool> getCachedResult() const;
+  void cacheResult(bool value) const;
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -147,3 +147,7 @@ SWIFT_REQUEST(TypeChecker, USRGenerationRequest, std::string(const ValueDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsABICompatibleOverrideRequest,
               bool(ValueDecl *), Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, IsStaticRequest,
+              bool(FuncDecl *), SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, NeedsNewVTableEntryRequest,
+              bool(AbstractFunctionDecl *), SeparatelyCached, NoLocationInfo)

include/swift/AST/USRGeneration.h

@@ -9,6 +9,12 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
+//
+// Unique Symbol References (USRs) provide a textual encoding for
+// declarations. These are used for indexing, analogous to how mangled names
+// are used in object files.
+//
+//===----------------------------------------------------------------------===//
 
 #ifndef SWIFT_AST_USRGENERATION_H
 #define SWIFT_AST_USRGENERATION_H

include/swift/Basic/LangOptions.h

@@ -329,9 +329,7 @@ namespace swift {
 
     /// Whether to enable experimental differentiable programming features:
     /// `@differentiable` declaration attribute, etc.
-    // SWIFT_ENABLE_TENSORFLOW
-    // The default on tensorflow branch is true. On master, it is false.
-    bool EnableExperimentalDifferentiableProgramming = true;
+    bool EnableExperimentalDifferentiableProgramming = false;
 
     /// Whether to enable #quote, #unquote and @quoted.
     bool EnableExperimentalQuasiquotes = false;

include/swift/Basic/StringExtras.h

@@ -21,7 +21,6 @@
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/OptionSet.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/Allocator.h"
@@ -65,6 +64,8 @@ namespace swift {
 
   public:
     StringRef copyString(StringRef string);
+
+    llvm::BumpPtrAllocator &getAllocator() { return Allocator; }
   };
 
   namespace camel_case {
@@ -430,11 +431,13 @@ StringRef matchLeadingTypeName(StringRef name, OmissionTypeName typeName);
 /// Describes a set of names with an inheritance relationship.
 class InheritedNameSet {
   const InheritedNameSet *Parent;
-  llvm::StringSet<> Names;
+  llvm::StringSet<llvm::BumpPtrAllocator &> Names;
 
 public:
   /// Construct a new inherited name set with the given parent.
-  explicit InheritedNameSet(const InheritedNameSet *parent) : Parent(parent) { }
+  InheritedNameSet(const InheritedNameSet *parent,
+                   llvm::BumpPtrAllocator &allocator)
+      : Parent(parent), Names(allocator) { }
 
   // Add a new name to the set.
   void add(StringRef name);

include/swift/Parse/ASTGen.h

@@ -79,6 +79,11 @@ class ASTGen {
   //===--------------------------------------------------------------------===//
   // Expressions.
 
+  Expr *generate(const syntax::ExprSyntax &Expr, const SourceLoc Loc);
+  Expr *generate(const syntax::IdentifierExprSyntax &Expr, const SourceLoc Loc);
+  Expr *generate(const syntax::EditorPlaceholderExprSyntax &Expr,
+                 const SourceLoc Loc);
+  Expr *generate(const syntax::SpecializeExprSyntax &Expr, const SourceLoc Loc);
   Expr *generate(const syntax::IntegerLiteralExprSyntax &Expr,
                  const SourceLoc Loc);
   Expr *generate(const syntax::FloatLiteralExprSyntax &Expr,
@@ -96,7 +101,13 @@ class ASTGen {
                  const SourceLoc Loc);
   Expr *generate(const syntax::UnknownExprSyntax &Expr, const SourceLoc Loc);
 
+  std::pair<DeclName, DeclNameLoc> generateUnqualifiedDeclName(
+      const syntax::TokenSyntax &idTok,
+      const Optional<syntax::DeclNameArgumentsSyntax> &args,
+      const SourceLoc Loc);
+
 private:
+
   Expr *generateMagicIdentifierLiteralExpression(
       const syntax::TokenSyntax &PoundToken, const SourceLoc Loc);
 
@@ -168,10 +179,9 @@ class ASTGen {
   //===--------------------------------------------------------------------===//
   // Generics.
 
-  TypeRepr *generate(const syntax::GenericArgumentSyntax &Arg,
-                     const SourceLoc Loc);
-  llvm::SmallVector<TypeRepr *, 4>
-  generate(const syntax::GenericArgumentListSyntax &Args, const SourceLoc Loc);
+  void generate(const syntax::GenericArgumentClauseSyntax &Arg,
+                const SourceLoc Loc, SourceLoc &lAngleLoc, SourceLoc &rAngleLoc,
+                SmallVectorImpl<TypeRepr *> &args);
 
   GenericParamList *
   generate(const syntax::GenericParameterClauseListSyntax &clause,