---

yaml
---
r: 348914
b: refs/heads/master
c: bc1a3ea
h: refs/heads/master

Author: xedin

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 51476cde58d89b6abf5424e3c7c3f65606a74c45
+refs/heads/master: bc1a3eaaa5b213fd0f8d5679ac1f905208c44e83
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/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)

trunk/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@")

trunk/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,
@@ -3547,8 +3541,6 @@ class EnumDecl final : public NominalTypeDecl {
     return SourceRange(EnumLoc, getBraces().End);
   }
 
-  EnumElementDecl *getElement(Identifier Name) const;
-  
 public:
   /// A range for iterating the elements of an enum.
   using ElementRange = DowncastFilterRange<EnumElementDecl, DeclRange>;
@@ -5553,6 +5545,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.
@@ -5622,6 +5616,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,
@@ -5633,8 +5632,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;
   }
@@ -5804,16 +5801,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) >
@@ -6363,13 +6353,7 @@ class EnumElementDecl : public DeclContext, public ValueDecl {
                   ParameterList *Params,
                   SourceLoc EqualsLoc,
                   LiteralExpr *RawValueExpr,
-                  DeclContext *DC)
-  : DeclContext(DeclContextKind::EnumElementDecl, DC),
-    ValueDecl(DeclKind::EnumElement, DC, Name, IdentifierLoc),
-    Params(Params),
-    EqualsLoc(EqualsLoc),
-    RawValueExpr(RawValueExpr)
-  {}
+                  DeclContext *DC);
 
   Identifier getName() const { return getFullName().getBaseIdentifier(); }
 
@@ -6385,6 +6369,7 @@ class EnumElementDecl : public DeclContext, public ValueDecl {
 
   Type getArgumentInterfaceType() const;
 
+  void setParameterList(ParameterList *params);
   ParameterList *getParameterList() const { return Params; }
 
   /// Retrieves a fully typechecked raw value expression associated

trunk/include/swift/AST/TypeCheckRequests.h

@@ -1314,6 +1314,27 @@ class IsStaticRequest :
   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<>

trunk/include/swift/AST/TypeCheckerTypeIDZone.def

@@ -149,3 +149,5 @@ SWIFT_REQUEST(TypeChecker, IsABICompatibleOverrideRequest,
               bool(ValueDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsStaticRequest,
               bool(FuncDecl *), SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, NeedsNewVTableEntryRequest,
+              bool(AbstractFunctionDecl *), SeparatelyCached, NoLocationInfo)

trunk/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

trunk/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);

trunk/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,

trunk/include/swift/Parse/Parser.h

@@ -1480,6 +1480,8 @@ class Parser {
   /// _)
   /// \param loc The location of the label (empty if it doesn't exist)
   void parseOptionalArgumentLabel(Identifier &name, SourceLoc &loc);
+  bool parseOptionalArgumentLabelSyntax(Optional<ParsedTokenSyntax> &name,
+                                        Optional<ParsedTokenSyntax> &colon);
 
   /// Parse an unqualified-decl-name.
   ///
@@ -1498,10 +1500,20 @@ class Parser {
                                     bool allowOperators=false,
                                     bool allowZeroArgCompoundNames=false,
                                     bool allowDeinitAndSubscript=false);
+  ParserStatus
+  parseUnqualifiedDeclNameSyntax(Optional<ParsedTokenSyntax> &identTok,
+                                 Optional<ParsedDeclNameArgumentsSyntax> &declNameArg,
+                                 bool afterDot, const Diagnostic &diag,
+                                 bool allowOperators=false,
+                                 bool allowZeroArgCompoundNames=false,
+                                 bool allowDeinitAndSubscript=false);
+
+  ParsedSyntaxResult<ParsedExprSyntax> parseExprIdentifierSyntax();
+  ParsedSyntaxResult<ParsedExprSyntax>
+  parseExprSpecializeSyntax(ParsedExprSyntax &&);
 
   Expr *parseExprIdentifier();
-  Expr *parseExprEditorPlaceholder(Token PlaceholderTok,
-                                   Identifier PlaceholderId);
+  Expr *parseExprEditorPlaceholder(SourceLoc loc, StringRef text);
 
   /// Parse a closure expression after the opening brace.
   ///

trunk/include/swift/SIL/SILConstants.h

@@ -556,7 +556,7 @@ class SymbolicValue {
   void dump() const;
 };
 
-static_assert(sizeof(SymbolicValue) == 2 * sizeof(void *),
+static_assert(sizeof(SymbolicValue) == 2 * sizeof(uint64_t),
               "SymbolicValue should stay small");
 static_assert(std::is_pod<SymbolicValue>::value,
               "SymbolicValue should stay POD");

trunk/lib/AST/ASTMangler.cpp

@@ -2372,13 +2372,9 @@ CanType ASTMangler::getDeclTypeForMangling(
   }
 
 
-  Type type = decl->getInterfaceType()
-                  ->getReferenceStorageReferent();
-  if (type->hasArchetype()) {
-    assert(isa<ParamDecl>(decl) && "Only ParamDecl's still have archetypes");
-    type = type->mapTypeOutOfContext();
-  }
-  CanType canTy = type->getCanonicalType();
+  auto canTy = decl->getInterfaceType()
+                   ->getReferenceStorageReferent()
+                   ->getCanonicalType();
 
   if (auto gft = dyn_cast<GenericFunctionType>(canTy)) {
     genericSig = gft.getGenericSignature();